931860a9a1d95a21cf69aee18b8bd2cdf0af4907340b1a2808019fdac081e71f

.gitattributes

@@ -112,3 +112,4 @@ distribute_elements_into_two_arrays_ii/meta.json filter=lfs diff=lfs merge=lfs -
 divide_an_array_into_subarrays_with_minimum_cost_ii/meta.json filter=lfs diff=lfs merge=lfs -text
 divide_array_into_arrays_with_max_difference/meta.json filter=lfs diff=lfs merge=lfs -text
 divide_intervals_into_minimum_number_of_groups/meta.json filter=lfs diff=lfs merge=lfs -text
+eat_pizzas/meta.json filter=lfs diff=lfs merge=lfs -text

divide_intervals_into_minimum_number_of_groups/ocaml_tests/main.ml

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

divide_intervals_into_minimum_number_of_groups/scala_tests/MySuite.scala

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

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

divide_nodes_into_the_maximum_number_of_groups/java_tests/Main.java

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

divide_nodes_into_the_maximum_number_of_groups/ocaml_tests/main.ml

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

divide_nodes_into_the_maximum_number_of_groups/scala_tests/MySuite.scala

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

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

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

divide_players_into_teams_of_equal_skill/ocaml_tests/main.ml

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

divide_players_into_teams_of_equal_skill/scala_tests/MySuite.scala

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

divisible_and_non_divisible_sums_difference/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (differenceOfSums 10 3)," 19 (differenceOfSums 10 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (differenceOfSums 5 6)," 15 (differenceOfSums 5 6))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (differenceOfSums 5 1)," (-15) (differenceOfSums 5 1))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (differenceOfSums 827 713)," 340952 (differenceOfSums 827 713))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (differenceOfSums 957 390)," 456063 (differenceOfSums 957 390))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (differenceOfSums 941 790)," 441631 (differenceOfSums 941 790))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (differenceOfSums 224 255)," 25200 (differenceOfSums 224 255))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (differenceOfSums 17 99)," 153 (differenceOfSums 17 99))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (differenceOfSums 203 363)," 20706 (differenceOfSums 203 363))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

divisible_and_non_divisible_sums_difference/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(19, differenceOfSums(10, 3));
+}
+@Test
+public void test2() {
+    assertEquals(15, differenceOfSums(5, 6));
+}
+@Test
+public void test3() {
+    assertEquals(-15, differenceOfSums(5, 1));
+}
+
+}

divisible_and_non_divisible_sums_difference/meta.json

@@ -0,0 +1,102 @@
+{
+    "id": 3172,
+    "name": "divisible_and_non_divisible_sums_difference",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/divisible-and-non-divisible-sums-difference/",
+    "date": "2023-10-01 00:00:00",
+    "task_description": "You are given positive integers `n` and `m`. Define two integers as follows: `num1`: The sum of all integers in the range `[1, n]` (both **inclusive**) that are **not divisible** by `m`. `num2`: The sum of all integers in the range `[1, n]` (both **inclusive**) that are **divisible** by `m`. Return _the integer_ `num1 - num2`. **Example 1:** ``` **Input:** n = 10, m = 3 **Output:** 19 **Explanation:** In the given example: - Integers in the range [1, 10] that are not divisible by 3 are [1,2,4,5,7,8,10], num1 is the sum of those integers = 37. - Integers in the range [1, 10] that are divisible by 3 are [3,6,9], num2 is the sum of those integers = 18. We return 37 - 18 = 19 as the answer. ``` **Example 2:** ``` **Input:** n = 5, m = 6 **Output:** 15 **Explanation:** In the given example: - Integers in the range [1, 5] that are not divisible by 6 are [1,2,3,4,5], num1 is the sum of those integers = 15. - Integers in the range [1, 5] that are divisible by 6 are [], num2 is the sum of those integers = 0. We return 15 - 0 = 15 as the answer. ``` **Example 3:** ``` **Input:** n = 5, m = 1 **Output:** -15 **Explanation:** In the given example: - Integers in the range [1, 5] that are not divisible by 1 are [], num1 is the sum of those integers = 0. - Integers in the range [1, 5] that are divisible by 1 are [1,2,3,4,5], num2 is the sum of those integers = 15. We return 0 - 15 = -15 as the answer. ``` **Constraints:** `1 <= n, m <= 1000`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 10, m = 3",
+            "output": "19 "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 5, m = 6",
+            "output": "15 "
+        },
+        {
+            "label": "Example 3",
+            "input": "n = 5, m = 1",
+            "output": "-15 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                827,
+                713
+            ],
+            "output": 340952
+        },
+        {
+            "input": [
+                957,
+                390
+            ],
+            "output": 456063
+        },
+        {
+            "input": [
+                941,
+                790
+            ],
+            "output": 441631
+        },
+        {
+            "input": [
+                224,
+                255
+            ],
+            "output": 25200
+        },
+        {
+            "input": [
+                17,
+                99
+            ],
+            "output": 153
+        },
+        {
+            "input": [
+                203,
+                363
+            ],
+            "output": 20706
+        },
+        {
+            "input": [
+                151,
+                971
+            ],
+            "output": 11476
+        },
+        {
+            "input": [
+                726,
+                762
+            ],
+            "output": 263901
+        },
+        {
+            "input": [
+                997,
+                59
+            ],
+            "output": 481455
+        },
+        {
+            "input": [
+                999,
+                986
+            ],
+            "output": 497528
+        }
+    ],
+    "haskell_template": "differenceOfSums :: Int -> Int -> Int\ndifferenceOfSums n m ",
+    "ocaml_template": "let differenceOfSums (n: int) (m: int) : int =  ",
+    "scala_template": "def differenceOfSums(n: Int,m: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int differenceOfSums(int n, int m) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def differenceOfSums(self, n, m):\n        \"\"\"\n        :type n: int\n        :type m: int\n        :rtype: int\n        \"\"\"\n        "
+}

divisible_and_non_divisible_sums_difference/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 19 (differenceOfSums 10 3)
+
+let test2 _ = assert_equal 15 (differenceOfSums 5 6)
+
+let test3 _ = assert_equal (-15) (differenceOfSums 5 1)
+
+let test4 _ = assert_equal 340952 (differenceOfSums 827 713)
+
+let test5 _ = assert_equal 456063 (differenceOfSums 957 390)
+
+let test6 _ = assert_equal 441631 (differenceOfSums 941 790)
+
+let test7 _ = assert_equal 25200 (differenceOfSums 224 255)
+
+let test8 _ = assert_equal 153 (differenceOfSums 17 99)
+
+let test9 _ = assert_equal 20706 (differenceOfSums 203 363)
+
+let test10 _ = assert_equal 11476 (differenceOfSums 151 971)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for differenceOfSums" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+  "test9" >:: test9;
+  "test10" >:: test10;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

divisible_and_non_divisible_sums_difference/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.differenceOfSums(10,3), 19)
+  }
+
+  test("test2") {
+    assertEquals(Main.differenceOfSums(5,6), 15)
+  }
+
+  test("test3") {
+    assertEquals(Main.differenceOfSums(5,1), -15)
+  }
+
+  test("test4") {
+    assertEquals(Main.differenceOfSums(827,713), 340952)
+  }
+
+  test("test5") {
+    assertEquals(Main.differenceOfSums(957,390), 456063)
+  }
+
+  test("test6") {
+    assertEquals(Main.differenceOfSums(941,790), 441631)
+  }
+
+  test("test7") {
+    assertEquals(Main.differenceOfSums(224,255), 25200)
+  }
+
+  test("test8") {
+    assertEquals(Main.differenceOfSums(17,99), 153)
+  }
+
+  test("test9") {
+    assertEquals(Main.differenceOfSums(203,363), 20706)
+  }
+
+  test("test10") {
+    assertEquals(Main.differenceOfSums(151,971), 11476)
+  }
+
+}

double_modular_exponentiation/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (getGoodIndices [[2,3,3,10],[3,3,3,1],[6,1,1,4]] 2)," [0,2] (getGoodIndices [[2,3,3,10],[3,3,3,1],[6,1,1,4]] 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (getGoodIndices [[39,3,1000,1000]] 17)," [] (getGoodIndices [[39,3,1000,1000]] 17))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (getGoodIndices [[421, 377, 428, 165], [974, 742, 692, 350], [826, 560, 987, 757]] 143)," [] (getGoodIndices [[421, 377, 428, 165], [974, 742, 692, 350], [826, 560, 987, 757]] 143))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (getGoodIndices [[765, 245, 442, 420], [531, 902, 782, 675], [598, 622, 462, 829], [519, 17, 285, 454], [754, 818, 264, 34], [267, 54, 632, 323], [101, 332, 820, 72], [76, 579, 390, 12], [904, 523, 796, 307], [821, 209, 540, 668], [25, 603, 985, 140], [213, 823, 566, 823], [640, 78, 110, 6], [329, 508, 158, 997], [405, 840, 31, 104], [814, 139, 138, 447], [919, 935, 522, 626], [49, 25, 510, 236], [846, 119, 183, 956], [272, 849, 513, 91], [543, 726, 744, 269], [316, 561, 932, 235], [953, 843, 235, 320], [381, 895, 788, 480], [69, 477, 845, 383], [270, 102, 830, 266], [886, 406, 890, 315], [392, 835, 522, 614], [287, 313, 368, 775], [558, 67, 693, 344], [723, 564, 90, 381], [950, 571, 341, 775], [531, 909, 325, 713], [165, 201, 661, 21], [301, 689, 994, 518], [501, 132, 116, 180], [39, 232, 723, 753], [646, 578, 353, 71], [738, 287, 759, 385], [777, 553, 68, 238], [677, 13, 894, 297], [723, 155, 139, 792], [891, 272, 196, 568], [156, 356, 185, 499], [34, 756, 406, 15], [190, 243, 107, 252], [662, 547, 649, 666], [363, 726, 406, 953], [379, 496, 477, 453], [552, 954, 484, 732], [548, 238, 505, 45], [113, 679, 987, 145], [975, 463, 317, 692], [746, 540, 632, 772], [492, 257, 198, 980], [802, 838, 416, 782], [88, 315, 34, 395]] 942)," [] (getGoodIndices [[765, 245, 442, 420], [531, 902, 782, 675], [598, 622, 462, 829], [519, 17, 285, 454], [754, 818, 264, 34], [267, 54, 632, 323], [101, 332, 820, 72], [76, 579, 390, 12], [904, 523, 796, 307], [821, 209, 540, 668], [25, 603, 985, 140], [213, 823, 566, 823], [640, 78, 110, 6], [329, 508, 158, 997], [405, 840, 31, 104], [814, 139, 138, 447], [919, 935, 522, 626], [49, 25, 510, 236], [846, 119, 183, 956], [272, 849, 513, 91], [543, 726, 744, 269], [316, 561, 932, 235], [953, 843, 235, 320], [381, 895, 788, 480], [69, 477, 845, 383], [270, 102, 830, 266], [886, 406, 890, 315], [392, 835, 522, 614], [287, 313, 368, 775], [558, 67, 693, 344], [723, 564, 90, 381], [950, 571, 341, 775], [531, 909, 325, 713], [165, 201, 661, 21], [301, 689, 994, 518], [501, 132, 116, 180], [39, 232, 723, 753], [646, 578, 353, 71], [738, 287, 759, 385], [777, 553, 68, 238], [677, 13, 894, 297], [723, 155, 139, 792], [891, 272, 196, 568], [156, 356, 185, 499], [34, 756, 406, 15], [190, 243, 107, 252], [662, 547, 649, 666], [363, 726, 406, 953], [379, 496, 477, 453], [552, 954, 484, 732], [548, 238, 505, 45], [113, 679, 987, 145], [975, 463, 317, 692], [746, 540, 632, 772], [492, 257, 198, 980], [802, 838, 416, 782], [88, 315, 34, 395]] 942))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (getGoodIndices [[49, 533, 715, 737], [924, 897, 615, 101], [260, 131, 150, 918], [339, 462, 654, 276], [32, 767, 733, 978], [67, 883, 686, 626], [405, 321, 514, 716], [632, 376, 761, 338], [439, 1000, 156, 528], [87, 697, 84, 393], [684, 943, 837, 900], [326, 341, 868, 841], [142, 633, 342, 652], [294, 39, 296, 997], [35, 266, 62, 622], [11, 993, 775, 197], [893, 561, 863, 443], [92, 698, 743, 898], [793, 760, 708, 894], [548, 781, 487, 778], [289, 825, 321, 680], [628, 99, 912, 861], [627, 365, 475, 983], [669, 682, 681, 685], [914, 155, 752, 928], [649, 197, 921, 936], [135, 608, 32, 184], [270, 860, 434, 622], [815, 345, 501, 174], [819, 905, 643, 337], [644, 450, 22, 866], [120, 353, 623, 970], [458, 881, 872, 854], [547, 833, 855, 274], [121, 465, 388, 270], [175, 9, 815, 644], [157, 329, 216, 495], [398, 785, 529, 219], [896, 70, 244, 460], [943, 16, 568, 861], [363, 626, 973, 297], [397, 44, 92, 179], [494, 337, 729, 899], [750, 204, 840, 122], [37, 69, 68, 202], [452, 554, 248, 932], [540, 205, 629, 908], [756, 75, 973, 522], [60, 376, 810, 889], [351, 800, 930, 468], [352, 38, 789, 921], [929, 956, 909, 637], [246, 782, 974, 862], [495, 271, 475, 792], [106, 937, 243, 893], [922, 373, 956, 174], [177, 888, 611, 889], [963, 900, 153, 746], [395, 241, 550, 511], [202, 381, 700, 813], [471, 848, 331, 233], [299, 516, 910, 497], [293, 893, 784, 818], [773, 926, 287, 688], [306, 905, 694, 439], [682, 877, 886, 511], [195, 345, 401, 347], [271, 770, 84, 390], [22, 618, 595, 346], [71, 681, 146, 363], [604, 486, 669, 940], [980, 817, 838, 256], [691, 613, 458, 474], [820, 763, 708, 892], [671, 452, 760, 971], [654, 336, 997, 846], [806, 950, 694, 859], [309, 886, 76, 430], [74, 739, 871, 749], [510, 149, 846, 818], [361, 518, 497, 330], [586, 159, 975, 105], [548, 662, 963, 595], [856, 194, 657, 616]] 949)," [] (getGoodIndices [[49, 533, 715, 737], [924, 897, 615, 101], [260, 131, 150, 918], [339, 462, 654, 276], [32, 767, 733, 978], [67, 883, 686, 626], [405, 321, 514, 716], [632, 376, 761, 338], [439, 1000, 156, 528], [87, 697, 84, 393], [684, 943, 837, 900], [326, 341, 868, 841], [142, 633, 342, 652], [294, 39, 296, 997], [35, 266, 62, 622], [11, 993, 775, 197], [893, 561, 863, 443], [92, 698, 743, 898], [793, 760, 708, 894], [548, 781, 487, 778], [289, 825, 321, 680], [628, 99, 912, 861], [627, 365, 475, 983], [669, 682, 681, 685], [914, 155, 752, 928], [649, 197, 921, 936], [135, 608, 32, 184], [270, 860, 434, 622], [815, 345, 501, 174], [819, 905, 643, 337], [644, 450, 22, 866], [120, 353, 623, 970], [458, 881, 872, 854], [547, 833, 855, 274], [121, 465, 388, 270], [175, 9, 815, 644], [157, 329, 216, 495], [398, 785, 529, 219], [896, 70, 244, 460], [943, 16, 568, 861], [363, 626, 973, 297], [397, 44, 92, 179], [494, 337, 729, 899], [750, 204, 840, 122], [37, 69, 68, 202], [452, 554, 248, 932], [540, 205, 629, 908], [756, 75, 973, 522], [60, 376, 810, 889], [351, 800, 930, 468], [352, 38, 789, 921], [929, 956, 909, 637], [246, 782, 974, 862], [495, 271, 475, 792], [106, 937, 243, 893], [922, 373, 956, 174], [177, 888, 611, 889], [963, 900, 153, 746], [395, 241, 550, 511], [202, 381, 700, 813], [471, 848, 331, 233], [299, 516, 910, 497], [293, 893, 784, 818], [773, 926, 287, 688], [306, 905, 694, 439], [682, 877, 886, 511], [195, 345, 401, 347], [271, 770, 84, 390], [22, 618, 595, 346], [71, 681, 146, 363], [604, 486, 669, 940], [980, 817, 838, 256], [691, 613, 458, 474], [820, 763, 708, 892], [671, 452, 760, 971], [654, 336, 997, 846], [806, 950, 694, 859], [309, 886, 76, 430], [74, 739, 871, 749], [510, 149, 846, 818], [361, 518, 497, 330], [586, 159, 975, 105], [548, 662, 963, 595], [856, 194, 657, 616]] 949))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (getGoodIndices [[81, 172, 816, 189], [809, 835, 516, 976], [397, 971, 139, 93], [681, 583, 211, 893], [280, 14, 944, 299], [376, 487, 547, 109], [967, 509, 844, 522], [50, 465, 477, 439], [816, 204, 858, 24], [909, 456, 252, 478], [696, 242, 935, 324], [917, 999, 174, 120], [852, 237, 834, 506], [296, 5, 111, 748], [706, 607, 470, 176], [511, 3, 181, 780], [104, 121, 815, 559], [30, 888, 987, 809], [980, 646, 68, 621], [151, 159, 847, 511], [216, 153, 524, 81], [232, 344, 443, 608], [613, 48, 987, 567], [482, 734, 352, 296], [150, 54, 779, 387], [53, 208, 939, 212], [999, 667, 907, 712], [527, 974, 693, 275], [589, 415, 593, 251], [817, 108, 592, 653], [925, 383, 642, 863], [409, 263, 441, 288], [524, 586, 918, 266], [248, 923, 220, 764], [936, 616, 521, 106], [599, 688, 72, 819], [762, 876, 429, 494], [353, 724, 774, 394], [449, 376, 358, 861], [223, 743, 609, 507], [279, 890, 182, 381], [407, 227, 318, 292], [282, 543, 533, 892], [821, 464, 352, 213], [294, 289, 509, 759]] 957)," [] (getGoodIndices [[81, 172, 816, 189], [809, 835, 516, 976], [397, 971, 139, 93], [681, 583, 211, 893], [280, 14, 944, 299], [376, 487, 547, 109], [967, 509, 844, 522], [50, 465, 477, 439], [816, 204, 858, 24], [909, 456, 252, 478], [696, 242, 935, 324], [917, 999, 174, 120], [852, 237, 834, 506], [296, 5, 111, 748], [706, 607, 470, 176], [511, 3, 181, 780], [104, 121, 815, 559], [30, 888, 987, 809], [980, 646, 68, 621], [151, 159, 847, 511], [216, 153, 524, 81], [232, 344, 443, 608], [613, 48, 987, 567], [482, 734, 352, 296], [150, 54, 779, 387], [53, 208, 939, 212], [999, 667, 907, 712], [527, 974, 693, 275], [589, 415, 593, 251], [817, 108, 592, 653], [925, 383, 642, 863], [409, 263, 441, 288], [524, 586, 918, 266], [248, 923, 220, 764], [936, 616, 521, 106], [599, 688, 72, 819], [762, 876, 429, 494], [353, 724, 774, 394], [449, 376, 358, 861], [223, 743, 609, 507], [279, 890, 182, 381], [407, 227, 318, 292], [282, 543, 533, 892], [821, 464, 352, 213], [294, 289, 509, 759]] 957))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (getGoodIndices [[6, 114, 977, 509], [992, 896, 940, 360], [108, 232, 245, 708], [839, 994, 876, 132], [322, 274, 923, 515], [269, 439, 946, 817], [495, 776, 365, 373], [28, 782, 83, 118], [979, 942, 907, 111], [332, 664, 757, 833], [885, 939, 68, 113], [100, 104, 441, 578], [769, 192, 680, 494], [169, 51, 884, 261], [88, 60, 678, 51], [600, 260, 945, 893], [578, 223, 333, 561], [209, 752, 843, 166], [880, 569, 698, 597], [329, 525, 407, 1], [431, 192, 711, 50], [37, 855, 590, 473], [935, 795, 85, 290], [674, 556, 171, 211], [825, 850, 418, 517], [555, 737, 950, 132], [405, 203, 554, 263], [359, 170, 215, 258], [381, 593, 785, 679], [153, 704, 754, 957], [919, 758, 73, 131], [209, 121, 633, 452], [850, 903, 831, 189], [756, 405, 232, 235], [254, 574, 70, 107], [985, 221, 949, 601], [671, 449, 108, 913], [290, 917, 148, 391], [871, 77, 224, 852], [7, 41, 760, 862], [205, 212, 549, 576], [791, 683, 877, 501], [128, 808, 94, 594], [684, 588, 547, 118], [708, 724, 428, 997], [1, 515, 617, 413], [689, 970, 677, 288], [796, 841, 983, 774], [854, 842, 649, 972], [318, 13, 692, 791], [514, 801, 601, 835], [431, 810, 912, 183], [778, 552, 326, 620], [627, 343, 412, 901], [380, 264, 962, 825], [72, 869, 314, 356], [479, 701, 720, 380], [23, 52, 949, 882], [67, 648, 120, 709], [814, 251, 484, 453], [482, 903, 374, 308], [215, 393, 68, 708], [432, 689, 907, 548], [857, 652, 902, 652], [421, 413, 237, 5], [182, 165, 186, 942], [314, 622, 884, 857], [202, 236, 606, 575], [564, 55, 87, 474], [19, 759, 536, 282], [796, 1000, 689, 798], [484, 868, 402, 964], [272, 713, 258, 838], [523, 957, 746, 397], [665, 948, 815, 727], [267, 594, 16, 190], [969, 604, 257, 608], [985, 956, 429, 633], [916, 717, 532, 947], [701, 731, 143, 346], [541, 175, 216, 703], [557, 223, 184, 755], [641, 243, 833, 33], [217, 317, 296, 763], [608, 874, 70, 716], [392, 976, 115, 953], [209, 461, 42, 352]] 183)," [] (getGoodIndices [[6, 114, 977, 509], [992, 896, 940, 360], [108, 232, 245, 708], [839, 994, 876, 132], [322, 274, 923, 515], [269, 439, 946, 817], [495, 776, 365, 373], [28, 782, 83, 118], [979, 942, 907, 111], [332, 664, 757, 833], [885, 939, 68, 113], [100, 104, 441, 578], [769, 192, 680, 494], [169, 51, 884, 261], [88, 60, 678, 51], [600, 260, 945, 893], [578, 223, 333, 561], [209, 752, 843, 166], [880, 569, 698, 597], [329, 525, 407, 1], [431, 192, 711, 50], [37, 855, 590, 473], [935, 795, 85, 290], [674, 556, 171, 211], [825, 850, 418, 517], [555, 737, 950, 132], [405, 203, 554, 263], [359, 170, 215, 258], [381, 593, 785, 679], [153, 704, 754, 957], [919, 758, 73, 131], [209, 121, 633, 452], [850, 903, 831, 189], [756, 405, 232, 235], [254, 574, 70, 107], [985, 221, 949, 601], [671, 449, 108, 913], [290, 917, 148, 391], [871, 77, 224, 852], [7, 41, 760, 862], [205, 212, 549, 576], [791, 683, 877, 501], [128, 808, 94, 594], [684, 588, 547, 118], [708, 724, 428, 997], [1, 515, 617, 413], [689, 970, 677, 288], [796, 841, 983, 774], [854, 842, 649, 972], [318, 13, 692, 791], [514, 801, 601, 835], [431, 810, 912, 183], [778, 552, 326, 620], [627, 343, 412, 901], [380, 264, 962, 825], [72, 869, 314, 356], [479, 701, 720, 380], [23, 52, 949, 882], [67, 648, 120, 709], [814, 251, 484, 453], [482, 903, 374, 308], [215, 393, 68, 708], [432, 689, 907, 548], [857, 652, 902, 652], [421, 413, 237, 5], [182, 165, 186, 942], [314, 622, 884, 857], [202, 236, 606, 575], [564, 55, 87, 474], [19, 759, 536, 282], [796, 1000, 689, 798], [484, 868, 402, 964], [272, 713, 258, 838], [523, 957, 746, 397], [665, 948, 815, 727], [267, 594, 16, 190], [969, 604, 257, 608], [985, 956, 429, 633], [916, 717, 532, 947], [701, 731, 143, 346], [541, 175, 216, 703], [557, 223, 184, 755], [641, 243, 833, 33], [217, 317, 296, 763], [608, 874, 70, 716], [392, 976, 115, 953], [209, 461, 42, 352]] 183))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (getGoodIndices [[856, 748, 650, 124], [599, 74, 954, 720], [116, 112, 187, 459], [428, 787, 42, 243], [878, 169, 977, 267], [351, 952, 826, 534], [730, 760, 533, 507], [612, 167, 208, 56], [349, 752, 126, 743], [33, 575, 257, 955], [815, 571, 494, 987], [88, 322, 785, 329], [892, 795, 384, 496], [797, 873, 848, 768]] 407)," [] (getGoodIndices [[856, 748, 650, 124], [599, 74, 954, 720], [116, 112, 187, 459], [428, 787, 42, 243], [878, 169, 977, 267], [351, 952, 826, 534], [730, 760, 533, 507], [612, 167, 208, 56], [349, 752, 126, 743], [33, 575, 257, 955], [815, 571, 494, 987], [88, 322, 785, 329], [892, 795, 384, 496], [797, 873, 848, 768]] 407))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (getGoodIndices [[14, 878, 402, 407], [119, 107, 486, 233], [125, 80, 792, 504], [736, 647, 638, 163], [327, 465, 694, 681], [211, 281, 165, 386], [367, 201, 826, 849], [863, 520, 722, 684], [355, 609, 311, 798], [834, 455, 902, 854], [588, 90, 135, 391], [413, 824, 59, 558], [893, 549, 420, 899], [75, 689, 403, 773], [903, 451, 775, 882], [355, 597, 223, 600], [494, 613, 819, 216], [52, 966, 966, 121], [70, 721, 779, 47], [865, 606, 604, 472], [110, 628, 751, 123], [692, 72, 982, 58], [205, 640, 791, 422], [984, 652, 511, 224], [806, 180, 445, 995], [430, 603, 598, 48], [175, 699, 700, 602], [661, 825, 406, 892], [58, 849, 434, 798], [870, 146, 948, 823], [512, 134, 216, 352], [610, 137, 125, 97], [711, 349, 103, 414], [895, 440, 653, 260], [609, 264, 3, 300], [981, 577, 365, 681], [41, 406, 773, 688], [222, 359, 450, 29], [354, 776, 679, 773], [975, 931, 142, 736], [135, 272, 914, 855], [883, 967, 239, 928], [900, 735, 587, 120], [515, 421, 809, 961], [863, 68, 310, 33], [709, 487, 972, 559], [132, 211, 686, 644], [828, 944, 653, 544], [17, 341, 781, 214], [187, 271, 354, 656], [1, 46, 897, 685], [549, 945, 952, 120], [535, 745, 438, 286], [348, 781, 265, 119], [627, 854, 993, 633], [21, 273, 451, 965], [346, 260, 623, 616], [9, 152, 906, 545], [455, 37, 410, 650], [300, 571, 685, 624], [982, 9, 26, 748]] 169)," [] (getGoodIndices [[14, 878, 402, 407], [119, 107, 486, 233], [125, 80, 792, 504], [736, 647, 638, 163], [327, 465, 694, 681], [211, 281, 165, 386], [367, 201, 826, 849], [863, 520, 722, 684], [355, 609, 311, 798], [834, 455, 902, 854], [588, 90, 135, 391], [413, 824, 59, 558], [893, 549, 420, 899], [75, 689, 403, 773], [903, 451, 775, 882], [355, 597, 223, 600], [494, 613, 819, 216], [52, 966, 966, 121], [70, 721, 779, 47], [865, 606, 604, 472], [110, 628, 751, 123], [692, 72, 982, 58], [205, 640, 791, 422], [984, 652, 511, 224], [806, 180, 445, 995], [430, 603, 598, 48], [175, 699, 700, 602], [661, 825, 406, 892], [58, 849, 434, 798], [870, 146, 948, 823], [512, 134, 216, 352], [610, 137, 125, 97], [711, 349, 103, 414], [895, 440, 653, 260], [609, 264, 3, 300], [981, 577, 365, 681], [41, 406, 773, 688], [222, 359, 450, 29], [354, 776, 679, 773], [975, 931, 142, 736], [135, 272, 914, 855], [883, 967, 239, 928], [900, 735, 587, 120], [515, 421, 809, 961], [863, 68, 310, 33], [709, 487, 972, 559], [132, 211, 686, 644], [828, 944, 653, 544], [17, 341, 781, 214], [187, 271, 354, 656], [1, 46, 897, 685], [549, 945, 952, 120], [535, 745, 438, 286], [348, 781, 265, 119], [627, 854, 993, 633], [21, 273, 451, 965], [346, 260, 623, 616], [9, 152, 906, 545], [455, 37, 410, 650], [300, 571, 685, 624], [982, 9, 26, 748]] 169))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

double_modular_exponentiation/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(0,2)), getGoodIndices(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(2,3,3,10)),new ArrayList<>(Arrays.asList(3,3,3,1)),new ArrayList<>(Arrays.asList(6,1,1,4)))), 2));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(), getGoodIndices(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(39,3,1000,1000)))), 17));
+}
+
+}

double_modular_exponentiation/meta.json

@@ -0,0 +1,2189 @@
+{
+    "id": 3234,
+    "name": "double_modular_exponentiation",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/double-modular-exponentiation/",
+    "date": "2023-12-03 00:00:00",
+    "task_description": "You are given a **0-indexed** 2D array `variables` where `variables[i] = [ai, bi, ci, mi]`, and an integer `target`. An index `i` is **good** if the following formula holds: `0 <= i < variables.length` `((aibi % 10)ci) % mi == target` Return _an array consisting of **good** indices in **any order**_. **Example 1:** ``` **Input:** variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2 **Output:** [0,2] **Explanation:** For each index i in the variables array: 1) For the index 0, variables[0] = [2,3,3,10], (23 % 10)3 % 10 = 2. 2) For the index 1, variables[1] = [3,3,3,1], (33 % 10)3 % 1 = 0. 3) For the index 2, variables[2] = [6,1,1,4], (61 % 10)1 % 4 = 2. Therefore we return [0,2] as the answer. ``` **Example 2:** ``` **Input:** variables = [[39,3,1000,1000]], target = 17 **Output:** [] **Explanation:** For each index i in the variables array: 1) For the index 0, variables[0] = [39,3,1000,1000], (393 % 10)1000 % 1000 = 1. Therefore we return [] as the answer. ``` **Constraints:** `1 <= variables.length <= 100` `variables[i] == [ai, bi, ci, mi]` `1 <= ai, bi, ci, mi <= 103` `0 <= target <= 103`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2",
+            "output": "[0,2] "
+        },
+        {
+            "label": "Example 2",
+            "input": "variables = [[39,3,1000,1000]], target = 17",
+            "output": "[] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    [
+                        421,
+                        377,
+                        428,
+                        165
+                    ],
+                    [
+                        974,
+                        742,
+                        692,
+                        350
+                    ],
+                    [
+                        826,
+                        560,
+                        987,
+                        757
+                    ]
+                ],
+                143
+            ],
+            "output": []
+        },
+        {
+            "input": [
+                [
+                    [
+                        765,
+                        245,
+                        442,
+                        420
+                    ],
+                    [
+                        531,
+                        902,
+                        782,
+                        675
+                    ],
+                    [
+                        598,
+                        622,
+                        462,
+                        829
+                    ],
+                    [
+                        519,
+                        17,
+                        285,
+                        454
+                    ],
+                    [
+                        754,
+                        818,
+                        264,
+                        34
+                    ],
+                    [
+                        267,
+                        54,
+                        632,
+                        323
+                    ],
+                    [
+                        101,
+                        332,
+                        820,
+                        72
+                    ],
+                    [
+                        76,
+                        579,
+                        390,
+                        12
+                    ],
+                    [
+                        904,
+                        523,
+                        796,
+                        307
+                    ],
+                    [
+                        821,
+                        209,
+                        540,
+                        668
+                    ],
+                    [
+                        25,
+                        603,
+                        985,
+                        140
+                    ],
+                    [
+                        213,
+                        823,
+                        566,
+                        823
+                    ],
+                    [
+                        640,
+                        78,
+                        110,
+                        6
+                    ],
+                    [
+                        329,
+                        508,
+                        158,
+                        997
+                    ],
+                    [
+                        405,
+                        840,
+                        31,
+                        104
+                    ],
+                    [
+                        814,
+                        139,
+                        138,
+                        447
+                    ],
+                    [
+                        919,
+                        935,
+                        522,
+                        626
+                    ],
+                    [
+                        49,
+                        25,
+                        510,
+                        236
+                    ],
+                    [
+                        846,
+                        119,
+                        183,
+                        956
+                    ],
+                    [
+                        272,
+                        849,
+                        513,
+                        91
+                    ],
+                    [
+                        543,
+                        726,
+                        744,
+                        269
+                    ],
+                    [
+                        316,
+                        561,
+                        932,
+                        235
+                    ],
+                    [
+                        953,
+                        843,
+                        235,
+                        320
+                    ],
+                    [
+                        381,
+                        895,
+                        788,
+                        480
+                    ],
+                    [
+                        69,
+                        477,
+                        845,
+                        383
+                    ],
+                    [
+                        270,
+                        102,
+                        830,
+                        266
+                    ],
+                    [
+                        886,
+                        406,
+                        890,
+                        315
+                    ],
+                    [
+                        392,
+                        835,
+                        522,
+                        614
+                    ],
+                    [
+                        287,
+                        313,
+                        368,
+                        775
+                    ],
+                    [
+                        558,
+                        67,
+                        693,
+                        344
+                    ],
+                    [
+                        723,
+                        564,
+                        90,
+                        381
+                    ],
+                    [
+                        950,
+                        571,
+                        341,
+                        775
+                    ],
+                    [
+                        531,
+                        909,
+                        325,
+                        713
+                    ],
+                    [
+                        165,
+                        201,
+                        661,
+                        21
+                    ],
+                    [
+                        301,
+                        689,
+                        994,
+                        518
+                    ],
+                    [
+                        501,
+                        132,
+                        116,
+                        180
+                    ],
+                    [
+                        39,
+                        232,
+                        723,
+                        753
+                    ],
+                    [
+                        646,
+                        578,
+                        353,
+                        71
+                    ],
+                    [
+                        738,
+                        287,
+                        759,
+                        385
+                    ],
+                    [
+                        777,
+                        553,
+                        68,
+                        238
+                    ],
+                    [
+                        677,
+                        13,
+                        894,
+                        297
+                    ],
+                    [
+                        723,
+                        155,
+                        139,
+                        792
+                    ],
+                    [
+                        891,
+                        272,
+                        196,
+                        568
+                    ],
+                    [
+                        156,
+                        356,
+                        185,
+                        499
+                    ],
+                    [
+                        34,
+                        756,
+                        406,
+                        15
+                    ],
+                    [
+                        190,
+                        243,
+                        107,
+                        252
+                    ],
+                    [
+                        662,
+                        547,
+                        649,
+                        666
+                    ],
+                    [
+                        363,
+                        726,
+                        406,
+                        953
+                    ],
+                    [
+                        379,
+                        496,
+                        477,
+                        453
+                    ],
+                    [
+                        552,
+                        954,
+                        484,
+                        732
+                    ],
+                    [
+                        548,
+                        238,
+                        505,
+                        45
+                    ],
+                    [
+                        113,
+                        679,
+                        987,
+                        145
+                    ],
+                    [
+                        975,
+                        463,
+                        317,
+                        692
+                    ],
+                    [
+                        746,
+                        540,
+                        632,
+                        772
+                    ],
+                    [
+                        492,
+                        257,
+                        198,
+                        980
+                    ],
+                    [
+                        802,
+                        838,
+                        416,
+                        782
+                    ],
+                    [
+                        88,
+                        315,
+                        34,
+                        395
+                    ]
+                ],
+                942
+            ],
+            "output": []
+        },
+        {
+            "input": [
+                [
+                    [
+                        49,
+                        533,
+                        715,
+                        737
+                    ],
+                    [
+                        924,
+                        897,
+                        615,
+                        101
+                    ],
+                    [
+                        260,
+                        131,
+                        150,
+                        918
+                    ],
+                    [
+                        339,
+                        462,
+                        654,
+                        276
+                    ],
+                    [
+                        32,
+                        767,
+                        733,
+                        978
+                    ],
+                    [
+                        67,
+                        883,
+                        686,
+                        626
+                    ],
+                    [
+                        405,
+                        321,
+                        514,
+                        716
+                    ],
+                    [
+                        632,
+                        376,
+                        761,
+                        338
+                    ],
+                    [
+                        439,
+                        1000,
+                        156,
+                        528
+                    ],
+                    [
+                        87,
+                        697,
+                        84,
+                        393
+                    ],
+                    [
+                        684,
+                        943,
+                        837,
+                        900
+                    ],
+                    [
+                        326,
+                        341,
+                        868,
+                        841
+                    ],
+                    [
+                        142,
+                        633,
+                        342,
+                        652
+                    ],
+                    [
+                        294,
+                        39,
+                        296,
+                        997
+                    ],
+                    [
+                        35,
+                        266,
+                        62,
+                        622
+                    ],
+                    [
+                        11,
+                        993,
+                        775,
+                        197
+                    ],
+                    [
+                        893,
+                        561,
+                        863,
+                        443
+                    ],
+                    [
+                        92,
+                        698,
+                        743,
+                        898
+                    ],
+                    [
+                        793,
+                        760,
+                        708,
+                        894
+                    ],
+                    [
+                        548,
+                        781,
+                        487,
+                        778
+                    ],
+                    [
+                        289,
+                        825,
+                        321,
+                        680
+                    ],
+                    [
+                        628,
+                        99,
+                        912,
+                        861
+                    ],
+                    [
+                        627,
+                        365,
+                        475,
+                        983
+                    ],
+                    [
+                        669,
+                        682,
+                        681,
+                        685
+                    ],
+                    [
+                        914,
+                        155,
+                        752,
+                        928
+                    ],
+                    [
+                        649,
+                        197,
+                        921,
+                        936
+                    ],
+                    [
+                        135,
+                        608,
+                        32,
+                        184
+                    ],
+                    [
+                        270,
+                        860,
+                        434,
+                        622
+                    ],
+                    [
+                        815,
+                        345,
+                        501,
+                        174
+                    ],
+                    [
+                        819,
+                        905,
+                        643,
+                        337
+                    ],
+                    [
+                        644,
+                        450,
+                        22,
+                        866
+                    ],
+                    [
+                        120,
+                        353,
+                        623,
+                        970
+                    ],
+                    [
+                        458,
+                        881,
+                        872,
+                        854
+                    ],
+                    [
+                        547,
+                        833,
+                        855,
+                        274
+                    ],
+                    [
+                        121,
+                        465,
+                        388,
+                        270
+                    ],
+                    [
+                        175,
+                        9,
+                        815,
+                        644
+                    ],
+                    [
+                        157,
+                        329,
+                        216,
+                        495
+                    ],
+                    [
+                        398,
+                        785,
+                        529,
+                        219
+                    ],
+                    [
+                        896,
+                        70,
+                        244,
+                        460
+                    ],
+                    [
+                        943,
+                        16,
+                        568,
+                        861
+                    ],
+                    [
+                        363,
+                        626,
+                        973,
+                        297
+                    ],
+                    [
+                        397,
+                        44,
+                        92,
+                        179
+                    ],
+                    [
+                        494,
+                        337,
+                        729,
+                        899
+                    ],
+                    [
+                        750,
+                        204,
+                        840,
+                        122
+                    ],
+                    [
+                        37,
+                        69,
+                        68,
+                        202
+                    ],
+                    [
+                        452,
+                        554,
+                        248,
+                        932
+                    ],
+                    [
+                        540,
+                        205,
+                        629,
+                        908
+                    ],
+                    [
+                        756,
+                        75,
+                        973,
+                        522
+                    ],
+                    [
+                        60,
+                        376,
+                        810,
+                        889
+                    ],
+                    [
+                        351,
+                        800,
+                        930,
+                        468
+                    ],
+                    [
+                        352,
+                        38,
+                        789,
+                        921
+                    ],
+                    [
+                        929,
+                        956,
+                        909,
+                        637
+                    ],
+                    [
+                        246,
+                        782,
+                        974,
+                        862
+                    ],
+                    [
+                        495,
+                        271,
+                        475,
+                        792
+                    ],
+                    [
+                        106,
+                        937,
+                        243,
+                        893
+                    ],
+                    [
+                        922,
+                        373,
+                        956,
+                        174
+                    ],
+                    [
+                        177,
+                        888,
+                        611,
+                        889
+                    ],
+                    [
+                        963,
+                        900,
+                        153,
+                        746
+                    ],
+                    [
+                        395,
+                        241,
+                        550,
+                        511
+                    ],
+                    [
+                        202,
+                        381,
+                        700,
+                        813
+                    ],
+                    [
+                        471,
+                        848,
+                        331,
+                        233
+                    ],
+                    [
+                        299,
+                        516,
+                        910,
+                        497
+                    ],
+                    [
+                        293,
+                        893,
+                        784,
+                        818
+                    ],
+                    [
+                        773,
+                        926,
+                        287,
+                        688
+                    ],
+                    [
+                        306,
+                        905,
+                        694,
+                        439
+                    ],
+                    [
+                        682,
+                        877,
+                        886,
+                        511
+                    ],
+                    [
+                        195,
+                        345,
+                        401,
+                        347
+                    ],
+                    [
+                        271,
+                        770,
+                        84,
+                        390
+                    ],
+                    [
+                        22,
+                        618,
+                        595,
+                        346
+                    ],
+                    [
+                        71,
+                        681,
+                        146,
+                        363
+                    ],
+                    [
+                        604,
+                        486,
+                        669,
+                        940
+                    ],
+                    [
+                        980,
+                        817,
+                        838,
+                        256
+                    ],
+                    [
+                        691,
+                        613,
+                        458,
+                        474
+                    ],
+                    [
+                        820,
+                        763,
+                        708,
+                        892
+                    ],
+                    [
+                        671,
+                        452,
+                        760,
+                        971
+                    ],
+                    [
+                        654,
+                        336,
+                        997,
+                        846
+                    ],
+                    [
+                        806,
+                        950,
+                        694,
+                        859
+                    ],
+                    [
+                        309,
+                        886,
+                        76,
+                        430
+                    ],
+                    [
+                        74,
+                        739,
+                        871,
+                        749
+                    ],
+                    [
+                        510,
+                        149,
+                        846,
+                        818
+                    ],
+                    [
+                        361,
+                        518,
+                        497,
+                        330
+                    ],
+                    [
+                        586,
+                        159,
+                        975,
+                        105
+                    ],
+                    [
+                        548,
+                        662,
+                        963,
+                        595
+                    ],
+                    [
+                        856,
+                        194,
+                        657,
+                        616
+                    ]
+                ],
+                949
+            ],
+            "output": []
+        },
+        {
+            "input": [
+                [
+                    [
+                        81,
+                        172,
+                        816,
+                        189
+                    ],
+                    [
+                        809,
+                        835,
+                        516,
+                        976
+                    ],
+                    [
+                        397,
+                        971,
+                        139,
+                        93
+                    ],
+                    [
+                        681,
+                        583,
+                        211,
+                        893
+                    ],
+                    [
+                        280,
+                        14,
+                        944,
+                        299
+                    ],
+                    [
+                        376,
+                        487,
+                        547,
+                        109
+                    ],
+                    [
+                        967,
+                        509,
+                        844,
+                        522
+                    ],
+                    [
+                        50,
+                        465,
+                        477,
+                        439
+                    ],
+                    [
+                        816,
+                        204,
+                        858,
+                        24
+                    ],
+                    [
+                        909,
+                        456,
+                        252,
+                        478
+                    ],
+                    [
+                        696,
+                        242,
+                        935,
+                        324
+                    ],
+                    [
+                        917,
+                        999,
+                        174,
+                        120
+                    ],
+                    [
+                        852,
+                        237,
+                        834,
+                        506
+                    ],
+                    [
+                        296,
+                        5,
+                        111,
+                        748
+                    ],
+                    [
+                        706,
+                        607,
+                        470,
+                        176
+                    ],
+                    [
+                        511,
+                        3,
+                        181,
+                        780
+                    ],
+                    [
+                        104,
+                        121,
+                        815,
+                        559
+                    ],
+                    [
+                        30,
+                        888,
+                        987,
+                        809
+                    ],
+                    [
+                        980,
+                        646,
+                        68,
+                        621
+                    ],
+                    [
+                        151,
+                        159,
+                        847,
+                        511
+                    ],
+                    [
+                        216,
+                        153,
+                        524,
+                        81
+                    ],
+                    [
+                        232,
+                        344,
+                        443,
+                        608
+                    ],
+                    [
+                        613,
+                        48,
+                        987,
+                        567
+                    ],
+                    [
+                        482,
+                        734,
+                        352,
+                        296
+                    ],
+                    [
+                        150,
+                        54,
+                        779,
+                        387
+                    ],
+                    [
+                        53,
+                        208,
+                        939,
+                        212
+                    ],
+                    [
+                        999,
+                        667,
+                        907,
+                        712
+                    ],
+                    [
+                        527,
+                        974,
+                        693,
+                        275
+                    ],
+                    [
+                        589,
+                        415,
+                        593,
+                        251
+                    ],
+                    [
+                        817,
+                        108,
+                        592,
+                        653
+                    ],
+                    [
+                        925,
+                        383,
+                        642,
+                        863
+                    ],
+                    [
+                        409,
+                        263,
+                        441,
+                        288
+                    ],
+                    [
+                        524,
+                        586,
+                        918,
+                        266
+                    ],
+                    [
+                        248,
+                        923,
+                        220,
+                        764
+                    ],
+                    [
+                        936,
+                        616,
+                        521,
+                        106
+                    ],
+                    [
+                        599,
+                        688,
+                        72,
+                        819
+                    ],
+                    [
+                        762,
+                        876,
+                        429,
+                        494
+                    ],
+                    [
+                        353,
+                        724,
+                        774,
+                        394
+                    ],
+                    [
+                        449,
+                        376,
+                        358,
+                        861
+                    ],
+                    [
+                        223,
+                        743,
+                        609,
+                        507
+                    ],
+                    [
+                        279,
+                        890,
+                        182,
+                        381
+                    ],
+                    [
+                        407,
+                        227,
+                        318,
+                        292
+                    ],
+                    [
+                        282,
+                        543,
+                        533,
+                        892
+                    ],
+                    [
+                        821,
+                        464,
+                        352,
+                        213
+                    ],
+                    [
+                        294,
+                        289,
+                        509,
+                        759
+                    ]
+                ],
+                957
+            ],
+            "output": []
+        },
+        {
+            "input": [
+                [
+                    [
+                        6,
+                        114,
+                        977,
+                        509
+                    ],
+                    [
+                        992,
+                        896,
+                        940,
+                        360
+                    ],
+                    [
+                        108,
+                        232,
+                        245,
+                        708
+                    ],
+                    [
+                        839,
+                        994,
+                        876,
+                        132
+                    ],
+                    [
+                        322,
+                        274,
+                        923,
+                        515
+                    ],
+                    [
+                        269,
+                        439,
+                        946,
+                        817
+                    ],
+                    [
+                        495,
+                        776,
+                        365,
+                        373
+                    ],
+                    [
+                        28,
+                        782,
+                        83,
+                        118
+                    ],
+                    [
+                        979,
+                        942,
+                        907,
+                        111
+                    ],
+                    [
+                        332,
+                        664,
+                        757,
+                        833
+                    ],
+                    [
+                        885,
+                        939,
+                        68,
+                        113
+                    ],
+                    [
+                        100,
+                        104,
+                        441,
+                        578
+                    ],
+                    [
+                        769,
+                        192,
+                        680,
+                        494
+                    ],
+                    [
+                        169,
+                        51,
+                        884,
+                        261
+                    ],
+                    [
+                        88,
+                        60,
+                        678,
+                        51
+                    ],
+                    [
+                        600,
+                        260,
+                        945,
+                        893
+                    ],
+                    [
+                        578,
+                        223,
+                        333,
+                        561
+                    ],
+                    [
+                        209,
+                        752,
+                        843,
+                        166
+                    ],
+                    [
+                        880,
+                        569,
+                        698,
+                        597
+                    ],
+                    [
+                        329,
+                        525,
+                        407,
+                        1
+                    ],
+                    [
+                        431,
+                        192,
+                        711,
+                        50
+                    ],
+                    [
+                        37,
+                        855,
+                        590,
+                        473
+                    ],
+                    [
+                        935,
+                        795,
+                        85,
+                        290
+                    ],
+                    [
+                        674,
+                        556,
+                        171,
+                        211
+                    ],
+                    [
+                        825,
+                        850,
+                        418,
+                        517
+                    ],
+                    [
+                        555,
+                        737,
+                        950,
+                        132
+                    ],
+                    [
+                        405,
+                        203,
+                        554,
+                        263
+                    ],
+                    [
+                        359,
+                        170,
+                        215,
+                        258
+                    ],
+                    [
+                        381,
+                        593,
+                        785,
+                        679
+                    ],
+                    [
+                        153,
+                        704,
+                        754,
+                        957
+                    ],
+                    [
+                        919,
+                        758,
+                        73,
+                        131
+                    ],
+                    [
+                        209,
+                        121,
+                        633,
+                        452
+                    ],
+                    [
+                        850,
+                        903,
+                        831,
+                        189
+                    ],
+                    [
+                        756,
+                        405,
+                        232,
+                        235
+                    ],
+                    [
+                        254,
+                        574,
+                        70,
+                        107
+                    ],
+                    [
+                        985,
+                        221,
+                        949,
+                        601
+                    ],
+                    [
+                        671,
+                        449,
+                        108,
+                        913
+                    ],
+                    [
+                        290,
+                        917,
+                        148,
+                        391
+                    ],
+                    [
+                        871,
+                        77,
+                        224,
+                        852
+                    ],
+                    [
+                        7,
+                        41,
+                        760,
+                        862
+                    ],
+                    [
+                        205,
+                        212,
+                        549,
+                        576
+                    ],
+                    [
+                        791,
+                        683,
+                        877,
+                        501
+                    ],
+                    [
+                        128,
+                        808,
+                        94,
+                        594
+                    ],
+                    [
+                        684,
+                        588,
+                        547,
+                        118
+                    ],
+                    [
+                        708,
+                        724,
+                        428,
+                        997
+                    ],
+                    [
+                        1,
+                        515,
+                        617,
+                        413
+                    ],
+                    [
+                        689,
+                        970,
+                        677,
+                        288
+                    ],
+                    [
+                        796,
+                        841,
+                        983,
+                        774
+                    ],
+                    [
+                        854,
+                        842,
+                        649,
+                        972
+                    ],
+                    [
+                        318,
+                        13,
+                        692,
+                        791
+                    ],
+                    [
+                        514,
+                        801,
+                        601,
+                        835
+                    ],
+                    [
+                        431,
+                        810,
+                        912,
+                        183
+                    ],
+                    [
+                        778,
+                        552,
+                        326,
+                        620
+                    ],
+                    [
+                        627,
+                        343,
+                        412,
+                        901
+                    ],
+                    [
+                        380,
+                        264,
+                        962,
+                        825
+                    ],
+                    [
+                        72,
+                        869,
+                        314,
+                        356
+                    ],
+                    [
+                        479,
+                        701,
+                        720,
+                        380
+                    ],
+                    [
+                        23,
+                        52,
+                        949,
+                        882
+                    ],
+                    [
+                        67,
+                        648,
+                        120,
+                        709
+                    ],
+                    [
+                        814,
+                        251,
+                        484,
+                        453
+                    ],
+                    [
+                        482,
+                        903,
+                        374,
+                        308
+                    ],
+                    [
+                        215,
+                        393,
+                        68,
+                        708
+                    ],
+                    [
+                        432,
+                        689,
+                        907,
+                        548
+                    ],
+                    [
+                        857,
+                        652,
+                        902,
+                        652
+                    ],
+                    [
+                        421,
+                        413,
+                        237,
+                        5
+                    ],
+                    [
+                        182,
+                        165,
+                        186,
+                        942
+                    ],
+                    [
+                        314,
+                        622,
+                        884,
+                        857
+                    ],
+                    [
+                        202,
+                        236,
+                        606,
+                        575
+                    ],
+                    [
+                        564,
+                        55,
+                        87,
+                        474
+                    ],
+                    [
+                        19,
+                        759,
+                        536,
+                        282
+                    ],
+                    [
+                        796,
+                        1000,
+                        689,
+                        798
+                    ],
+                    [
+                        484,
+                        868,
+                        402,
+                        964
+                    ],
+                    [
+                        272,
+                        713,
+                        258,
+                        838
+                    ],
+                    [
+                        523,
+                        957,
+                        746,
+                        397
+                    ],
+                    [
+                        665,
+                        948,
+                        815,
+                        727
+                    ],
+                    [
+                        267,
+                        594,
+                        16,
+                        190
+                    ],
+                    [
+                        969,
+                        604,
+                        257,
+                        608
+                    ],
+                    [
+                        985,
+                        956,
+                        429,
+                        633
+                    ],
+                    [
+                        916,
+                        717,
+                        532,
+                        947
+                    ],
+                    [
+                        701,
+                        731,
+                        143,
+                        346
+                    ],
+                    [
+                        541,
+                        175,
+                        216,
+                        703
+                    ],
+                    [
+                        557,
+                        223,
+                        184,
+                        755
+                    ],
+                    [
+                        641,
+                        243,
+                        833,
+                        33
+                    ],
+                    [
+                        217,
+                        317,
+                        296,
+                        763
+                    ],
+                    [
+                        608,
+                        874,
+                        70,
+                        716
+                    ],
+                    [
+                        392,
+                        976,
+                        115,
+                        953
+                    ],
+                    [
+                        209,
+                        461,
+                        42,
+                        352
+                    ]
+                ],
+                183
+            ],
+            "output": []
+        },
+        {
+            "input": [
+                [
+                    [
+                        856,
+                        748,
+                        650,
+                        124
+                    ],
+                    [
+                        599,
+                        74,
+                        954,
+                        720
+                    ],
+                    [
+                        116,
+                        112,
+                        187,
+                        459
+                    ],
+                    [
+                        428,
+                        787,
+                        42,
+                        243
+                    ],
+                    [
+                        878,
+                        169,
+                        977,
+                        267
+                    ],
+                    [
+                        351,
+                        952,
+                        826,
+                        534
+                    ],
+                    [
+                        730,
+                        760,
+                        533,
+                        507
+                    ],
+                    [
+                        612,
+                        167,
+                        208,
+                        56
+                    ],
+                    [
+                        349,
+                        752,
+                        126,
+                        743
+                    ],
+                    [
+                        33,
+                        575,
+                        257,
+                        955
+                    ],
+                    [
+                        815,
+                        571,
+                        494,
+                        987
+                    ],
+                    [
+                        88,
+                        322,
+                        785,
+                        329
+                    ],
+                    [
+                        892,
+                        795,
+                        384,
+                        496
+                    ],
+                    [
+                        797,
+                        873,
+                        848,
+                        768
+                    ]
+                ],
+                407
+            ],
+            "output": []
+        },
+        {
+            "input": [
+                [
+                    [
+                        14,
+                        878,
+                        402,
+                        407
+                    ],
+                    [
+                        119,
+                        107,
+                        486,
+                        233
+                    ],
+                    [
+                        125,
+                        80,
+                        792,
+                        504
+                    ],
+                    [
+                        736,
+                        647,
+                        638,
+                        163
+                    ],
+                    [
+                        327,
+                        465,
+                        694,
+                        681
+                    ],
+                    [
+                        211,
+                        281,
+                        165,
+                        386
+                    ],
+                    [
+                        367,
+                        201,
+                        826,
+                        849
+                    ],
+                    [
+                        863,
+                        520,
+                        722,
+                        684
+                    ],
+                    [
+                        355,
+                        609,
+                        311,
+                        798
+                    ],
+                    [
+                        834,
+                        455,
+                        902,
+                        854
+                    ],
+                    [
+                        588,
+                        90,
+                        135,
+                        391
+                    ],
+                    [
+                        413,
+                        824,
+                        59,
+                        558
+                    ],
+                    [
+                        893,
+                        549,
+                        420,
+                        899
+                    ],
+                    [
+                        75,
+                        689,
+                        403,
+                        773
+                    ],
+                    [
+                        903,
+                        451,
+                        775,
+                        882
+                    ],
+                    [
+                        355,
+                        597,
+                        223,
+                        600
+                    ],
+                    [
+                        494,
+                        613,
+                        819,
+                        216
+                    ],
+                    [
+                        52,
+                        966,
+                        966,
+                        121
+                    ],
+                    [
+                        70,
+                        721,
+                        779,
+                        47
+                    ],
+                    [
+                        865,
+                        606,
+                        604,
+                        472
+                    ],
+                    [
+                        110,
+                        628,
+                        751,
+                        123
+                    ],
+                    [
+                        692,
+                        72,
+                        982,
+                        58
+                    ],
+                    [
+                        205,
+                        640,
+                        791,
+                        422
+                    ],
+                    [
+                        984,
+                        652,
+                        511,
+                        224
+                    ],
+                    [
+                        806,
+                        180,
+                        445,
+                        995
+                    ],
+                    [
+                        430,
+                        603,
+                        598,
+                        48
+                    ],
+                    [
+                        175,
+                        699,
+                        700,
+                        602
+                    ],
+                    [
+                        661,
+                        825,
+                        406,
+                        892
+                    ],
+                    [
+                        58,
+                        849,
+                        434,
+                        798
+                    ],
+                    [
+                        870,
+                        146,
+                        948,
+                        823
+                    ],
+                    [
+                        512,
+                        134,
+                        216,
+                        352
+                    ],
+                    [
+                        610,
+                        137,
+                        125,
+                        97
+                    ],
+                    [
+                        711,
+                        349,
+                        103,
+                        414
+                    ],
+                    [
+                        895,
+                        440,
+                        653,
+                        260
+                    ],
+                    [
+                        609,
+                        264,
+                        3,
+                        300
+                    ],
+                    [
+                        981,
+                        577,
+                        365,
+                        681
+                    ],
+                    [
+                        41,
+                        406,
+                        773,
+                        688
+                    ],
+                    [
+                        222,
+                        359,
+                        450,
+                        29
+                    ],
+                    [
+                        354,
+                        776,
+                        679,
+                        773
+                    ],
+                    [
+                        975,
+                        931,
+                        142,
+                        736
+                    ],
+                    [
+                        135,
+                        272,
+                        914,
+                        855
+                    ],
+                    [
+                        883,
+                        967,
+                        239,
+                        928
+                    ],
+                    [
+                        900,
+                        735,
+                        587,
+                        120
+                    ],
+                    [
+                        515,
+                        421,
+                        809,
+                        961
+                    ],
+                    [
+                        863,
+                        68,
+                        310,
+                        33
+                    ],
+                    [
+                        709,
+                        487,
+                        972,
+                        559
+                    ],
+                    [
+                        132,
+                        211,
+                        686,
+                        644
+                    ],
+                    [
+                        828,
+                        944,
+                        653,
+                        544
+                    ],
+                    [
+                        17,
+                        341,
+                        781,
+                        214
+                    ],
+                    [
+                        187,
+                        271,
+                        354,
+                        656
+                    ],
+                    [
+                        1,
+                        46,
+                        897,
+                        685
+                    ],
+                    [
+                        549,
+                        945,
+                        952,
+                        120
+                    ],
+                    [
+                        535,
+                        745,
+                        438,
+                        286
+                    ],
+                    [
+                        348,
+                        781,
+                        265,
+                        119
+                    ],
+                    [
+                        627,
+                        854,
+                        993,
+                        633
+                    ],
+                    [
+                        21,
+                        273,
+                        451,
+                        965
+                    ],
+                    [
+                        346,
+                        260,
+                        623,
+                        616
+                    ],
+                    [
+                        9,
+                        152,
+                        906,
+                        545
+                    ],
+                    [
+                        455,
+                        37,
+                        410,
+                        650
+                    ],
+                    [
+                        300,
+                        571,
+                        685,
+                        624
+                    ],
+                    [
+                        982,
+                        9,
+                        26,
+                        748
+                    ]
+                ],
+                169
+            ],
+            "output": []
+        }
+    ],
+    "haskell_template": "getGoodIndices :: [[Int]] -> Int -> [Int]\ngetGoodIndices variables target ",
+    "ocaml_template": "let getGoodIndices (variables: int list list) (target: int) : int list =  ",
+    "scala_template": "def getGoodIndices(variables: List[List[Int]],target: Int): List[Int] = { \n    \n}",
+    "java_template": "class Solution {\n    public List<Integer> getGoodIndices(int[][] variables, int target) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def getGoodIndices(self, variables, target):\n        \"\"\"\n        :type variables: List[List[int]]\n        :type target: int\n        :rtype: List[int]\n        \"\"\"\n        "
+}

double_modular_exponentiation/ocaml_tests/main.ml

@@ -0,0 +1,47 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal [0;2] (getGoodIndices [[2;3;3;10];[3;3;3;1];[6;1;1;4]] 2)
+
+let test2 _ = assert_equal [] (getGoodIndices [[39;3;1000;1000]] 17)
+
+let test3 _ = assert_equal [] (getGoodIndices [[421; 377; 428; 165]; [974; 742; 692; 350]; [826; 560; 987; 757]] 143)
+
+let test4 _ = assert_equal [] (getGoodIndices [[765; 245; 442; 420]; [531; 902; 782; 675]; [598; 622; 462; 829]; [519; 17; 285; 454]; [754; 818; 264; 34]; [267; 54; 632; 323]; [101; 332; 820; 72]; [76; 579; 390; 12]; [904; 523; 796; 307]; [821; 209; 540; 668]; [25; 603; 985; 140]; [213; 823; 566; 823]; [640; 78; 110; 6]; [329; 508; 158; 997]; [405; 840; 31; 104]; [814; 139; 138; 447]; [919; 935; 522; 626]; [49; 25; 510; 236]; [846; 119; 183; 956]; [272; 849; 513; 91]; [543; 726; 744; 269]; [316; 561; 932; 235]; [953; 843; 235; 320]; [381; 895; 788; 480]; [69; 477; 845; 383]; [270; 102; 830; 266]; [886; 406; 890; 315]; [392; 835; 522; 614]; [287; 313; 368; 775]; [558; 67; 693; 344]; [723; 564; 90; 381]; [950; 571; 341; 775]; [531; 909; 325; 713]; [165; 201; 661; 21]; [301; 689; 994; 518]; [501; 132; 116; 180]; [39; 232; 723; 753]; [646; 578; 353; 71]; [738; 287; 759; 385]; [777; 553; 68; 238]; [677; 13; 894; 297]; [723; 155; 139; 792]; [891; 272; 196; 568]; [156; 356; 185; 499]; [34; 756; 406; 15]; [190; 243; 107; 252]; [662; 547; 649; 666]; [363; 726; 406; 953]; [379; 496; 477; 453]; [552; 954; 484; 732]; [548; 238; 505; 45]; [113; 679; 987; 145]; [975; 463; 317; 692]; [746; 540; 632; 772]; [492; 257; 198; 980]; [802; 838; 416; 782]; [88; 315; 34; 395]] 942)
+
+let test5 _ = assert_equal [] (getGoodIndices [[49; 533; 715; 737]; [924; 897; 615; 101]; [260; 131; 150; 918]; [339; 462; 654; 276]; [32; 767; 733; 978]; [67; 883; 686; 626]; [405; 321; 514; 716]; [632; 376; 761; 338]; [439; 1000; 156; 528]; [87; 697; 84; 393]; [684; 943; 837; 900]; [326; 341; 868; 841]; [142; 633; 342; 652]; [294; 39; 296; 997]; [35; 266; 62; 622]; [11; 993; 775; 197]; [893; 561; 863; 443]; [92; 698; 743; 898]; [793; 760; 708; 894]; [548; 781; 487; 778]; [289; 825; 321; 680]; [628; 99; 912; 861]; [627; 365; 475; 983]; [669; 682; 681; 685]; [914; 155; 752; 928]; [649; 197; 921; 936]; [135; 608; 32; 184]; [270; 860; 434; 622]; [815; 345; 501; 174]; [819; 905; 643; 337]; [644; 450; 22; 866]; [120; 353; 623; 970]; [458; 881; 872; 854]; [547; 833; 855; 274]; [121; 465; 388; 270]; [175; 9; 815; 644]; [157; 329; 216; 495]; [398; 785; 529; 219]; [896; 70; 244; 460]; [943; 16; 568; 861]; [363; 626; 973; 297]; [397; 44; 92; 179]; [494; 337; 729; 899]; [750; 204; 840; 122]; [37; 69; 68; 202]; [452; 554; 248; 932]; [540; 205; 629; 908]; [756; 75; 973; 522]; [60; 376; 810; 889]; [351; 800; 930; 468]; [352; 38; 789; 921]; [929; 956; 909; 637]; [246; 782; 974; 862]; [495; 271; 475; 792]; [106; 937; 243; 893]; [922; 373; 956; 174]; [177; 888; 611; 889]; [963; 900; 153; 746]; [395; 241; 550; 511]; [202; 381; 700; 813]; [471; 848; 331; 233]; [299; 516; 910; 497]; [293; 893; 784; 818]; [773; 926; 287; 688]; [306; 905; 694; 439]; [682; 877; 886; 511]; [195; 345; 401; 347]; [271; 770; 84; 390]; [22; 618; 595; 346]; [71; 681; 146; 363]; [604; 486; 669; 940]; [980; 817; 838; 256]; [691; 613; 458; 474]; [820; 763; 708; 892]; [671; 452; 760; 971]; [654; 336; 997; 846]; [806; 950; 694; 859]; [309; 886; 76; 430]; [74; 739; 871; 749]; [510; 149; 846; 818]; [361; 518; 497; 330]; [586; 159; 975; 105]; [548; 662; 963; 595]; [856; 194; 657; 616]] 949)
+
+let test6 _ = assert_equal [] (getGoodIndices [[81; 172; 816; 189]; [809; 835; 516; 976]; [397; 971; 139; 93]; [681; 583; 211; 893]; [280; 14; 944; 299]; [376; 487; 547; 109]; [967; 509; 844; 522]; [50; 465; 477; 439]; [816; 204; 858; 24]; [909; 456; 252; 478]; [696; 242; 935; 324]; [917; 999; 174; 120]; [852; 237; 834; 506]; [296; 5; 111; 748]; [706; 607; 470; 176]; [511; 3; 181; 780]; [104; 121; 815; 559]; [30; 888; 987; 809]; [980; 646; 68; 621]; [151; 159; 847; 511]; [216; 153; 524; 81]; [232; 344; 443; 608]; [613; 48; 987; 567]; [482; 734; 352; 296]; [150; 54; 779; 387]; [53; 208; 939; 212]; [999; 667; 907; 712]; [527; 974; 693; 275]; [589; 415; 593; 251]; [817; 108; 592; 653]; [925; 383; 642; 863]; [409; 263; 441; 288]; [524; 586; 918; 266]; [248; 923; 220; 764]; [936; 616; 521; 106]; [599; 688; 72; 819]; [762; 876; 429; 494]; [353; 724; 774; 394]; [449; 376; 358; 861]; [223; 743; 609; 507]; [279; 890; 182; 381]; [407; 227; 318; 292]; [282; 543; 533; 892]; [821; 464; 352; 213]; [294; 289; 509; 759]] 957)
+
+let test7 _ = assert_equal [] (getGoodIndices [[6; 114; 977; 509]; [992; 896; 940; 360]; [108; 232; 245; 708]; [839; 994; 876; 132]; [322; 274; 923; 515]; [269; 439; 946; 817]; [495; 776; 365; 373]; [28; 782; 83; 118]; [979; 942; 907; 111]; [332; 664; 757; 833]; [885; 939; 68; 113]; [100; 104; 441; 578]; [769; 192; 680; 494]; [169; 51; 884; 261]; [88; 60; 678; 51]; [600; 260; 945; 893]; [578; 223; 333; 561]; [209; 752; 843; 166]; [880; 569; 698; 597]; [329; 525; 407; 1]; [431; 192; 711; 50]; [37; 855; 590; 473]; [935; 795; 85; 290]; [674; 556; 171; 211]; [825; 850; 418; 517]; [555; 737; 950; 132]; [405; 203; 554; 263]; [359; 170; 215; 258]; [381; 593; 785; 679]; [153; 704; 754; 957]; [919; 758; 73; 131]; [209; 121; 633; 452]; [850; 903; 831; 189]; [756; 405; 232; 235]; [254; 574; 70; 107]; [985; 221; 949; 601]; [671; 449; 108; 913]; [290; 917; 148; 391]; [871; 77; 224; 852]; [7; 41; 760; 862]; [205; 212; 549; 576]; [791; 683; 877; 501]; [128; 808; 94; 594]; [684; 588; 547; 118]; [708; 724; 428; 997]; [1; 515; 617; 413]; [689; 970; 677; 288]; [796; 841; 983; 774]; [854; 842; 649; 972]; [318; 13; 692; 791]; [514; 801; 601; 835]; [431; 810; 912; 183]; [778; 552; 326; 620]; [627; 343; 412; 901]; [380; 264; 962; 825]; [72; 869; 314; 356]; [479; 701; 720; 380]; [23; 52; 949; 882]; [67; 648; 120; 709]; [814; 251; 484; 453]; [482; 903; 374; 308]; [215; 393; 68; 708]; [432; 689; 907; 548]; [857; 652; 902; 652]; [421; 413; 237; 5]; [182; 165; 186; 942]; [314; 622; 884; 857]; [202; 236; 606; 575]; [564; 55; 87; 474]; [19; 759; 536; 282]; [796; 1000; 689; 798]; [484; 868; 402; 964]; [272; 713; 258; 838]; [523; 957; 746; 397]; [665; 948; 815; 727]; [267; 594; 16; 190]; [969; 604; 257; 608]; [985; 956; 429; 633]; [916; 717; 532; 947]; [701; 731; 143; 346]; [541; 175; 216; 703]; [557; 223; 184; 755]; [641; 243; 833; 33]; [217; 317; 296; 763]; [608; 874; 70; 716]; [392; 976; 115; 953]; [209; 461; 42; 352]] 183)
+
+let test8 _ = assert_equal [] (getGoodIndices [[856; 748; 650; 124]; [599; 74; 954; 720]; [116; 112; 187; 459]; [428; 787; 42; 243]; [878; 169; 977; 267]; [351; 952; 826; 534]; [730; 760; 533; 507]; [612; 167; 208; 56]; [349; 752; 126; 743]; [33; 575; 257; 955]; [815; 571; 494; 987]; [88; 322; 785; 329]; [892; 795; 384; 496]; [797; 873; 848; 768]] 407)
+
+let test9 _ = assert_equal [] (getGoodIndices [[14; 878; 402; 407]; [119; 107; 486; 233]; [125; 80; 792; 504]; [736; 647; 638; 163]; [327; 465; 694; 681]; [211; 281; 165; 386]; [367; 201; 826; 849]; [863; 520; 722; 684]; [355; 609; 311; 798]; [834; 455; 902; 854]; [588; 90; 135; 391]; [413; 824; 59; 558]; [893; 549; 420; 899]; [75; 689; 403; 773]; [903; 451; 775; 882]; [355; 597; 223; 600]; [494; 613; 819; 216]; [52; 966; 966; 121]; [70; 721; 779; 47]; [865; 606; 604; 472]; [110; 628; 751; 123]; [692; 72; 982; 58]; [205; 640; 791; 422]; [984; 652; 511; 224]; [806; 180; 445; 995]; [430; 603; 598; 48]; [175; 699; 700; 602]; [661; 825; 406; 892]; [58; 849; 434; 798]; [870; 146; 948; 823]; [512; 134; 216; 352]; [610; 137; 125; 97]; [711; 349; 103; 414]; [895; 440; 653; 260]; [609; 264; 3; 300]; [981; 577; 365; 681]; [41; 406; 773; 688]; [222; 359; 450; 29]; [354; 776; 679; 773]; [975; 931; 142; 736]; [135; 272; 914; 855]; [883; 967; 239; 928]; [900; 735; 587; 120]; [515; 421; 809; 961]; [863; 68; 310; 33]; [709; 487; 972; 559]; [132; 211; 686; 644]; [828; 944; 653; 544]; [17; 341; 781; 214]; [187; 271; 354; 656]; [1; 46; 897; 685]; [549; 945; 952; 120]; [535; 745; 438; 286]; [348; 781; 265; 119]; [627; 854; 993; 633]; [21; 273; 451; 965]; [346; 260; 623; 616]; [9; 152; 906; 545]; [455; 37; 410; 650]; [300; 571; 685; 624]; [982; 9; 26; 748]] 169)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for getGoodIndices" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+  "test9" >:: test9;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

double_modular_exponentiation/scala_tests/MySuite.scala

@@ -0,0 +1,40 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.getGoodIndices(List(List(2,3,3,10),List(3,3,3,1),List(6,1,1,4)),2), List(0,2))
+  }
+
+  test("test2") {
+    assertEquals(Main.getGoodIndices(List(List(39,3,1000,1000)),17), List())
+  }
+
+  test("test3") {
+    assertEquals(Main.getGoodIndices(List(List(421, 377, 428, 165), List(974, 742, 692, 350), List(826, 560, 987, 757)),143), List())
+  }
+
+  test("test4") {
+    assertEquals(Main.getGoodIndices(List(List(765, 245, 442, 420), List(531, 902, 782, 675), List(598, 622, 462, 829), List(519, 17, 285, 454), List(754, 818, 264, 34), List(267, 54, 632, 323), List(101, 332, 820, 72), List(76, 579, 390, 12), List(904, 523, 796, 307), List(821, 209, 540, 668), List(25, 603, 985, 140), List(213, 823, 566, 823), List(640, 78, 110, 6), List(329, 508, 158, 997), List(405, 840, 31, 104), List(814, 139, 138, 447), List(919, 935, 522, 626), List(49, 25, 510, 236), List(846, 119, 183, 956), List(272, 849, 513, 91), List(543, 726, 744, 269), List(316, 561, 932, 235), List(953, 843, 235, 320), List(381, 895, 788, 480), List(69, 477, 845, 383), List(270, 102, 830, 266), List(886, 406, 890, 315), List(392, 835, 522, 614), List(287, 313, 368, 775), List(558, 67, 693, 344), List(723, 564, 90, 381), List(950, 571, 341, 775), List(531, 909, 325, 713), List(165, 201, 661, 21), List(301, 689, 994, 518), List(501, 132, 116, 180), List(39, 232, 723, 753), List(646, 578, 353, 71), List(738, 287, 759, 385), List(777, 553, 68, 238), List(677, 13, 894, 297), List(723, 155, 139, 792), List(891, 272, 196, 568), List(156, 356, 185, 499), List(34, 756, 406, 15), List(190, 243, 107, 252), List(662, 547, 649, 666), List(363, 726, 406, 953), List(379, 496, 477, 453), List(552, 954, 484, 732), List(548, 238, 505, 45), List(113, 679, 987, 145), List(975, 463, 317, 692), List(746, 540, 632, 772), List(492, 257, 198, 980), List(802, 838, 416, 782), List(88, 315, 34, 395)),942), List())
+  }
+
+  test("test5") {
+    assertEquals(Main.getGoodIndices(List(List(49, 533, 715, 737), List(924, 897, 615, 101), List(260, 131, 150, 918), List(339, 462, 654, 276), List(32, 767, 733, 978), List(67, 883, 686, 626), List(405, 321, 514, 716), List(632, 376, 761, 338), List(439, 1000, 156, 528), List(87, 697, 84, 393), List(684, 943, 837, 900), List(326, 341, 868, 841), List(142, 633, 342, 652), List(294, 39, 296, 997), List(35, 266, 62, 622), List(11, 993, 775, 197), List(893, 561, 863, 443), List(92, 698, 743, 898), List(793, 760, 708, 894), List(548, 781, 487, 778), List(289, 825, 321, 680), List(628, 99, 912, 861), List(627, 365, 475, 983), List(669, 682, 681, 685), List(914, 155, 752, 928), List(649, 197, 921, 936), List(135, 608, 32, 184), List(270, 860, 434, 622), List(815, 345, 501, 174), List(819, 905, 643, 337), List(644, 450, 22, 866), List(120, 353, 623, 970), List(458, 881, 872, 854), List(547, 833, 855, 274), List(121, 465, 388, 270), List(175, 9, 815, 644), List(157, 329, 216, 495), List(398, 785, 529, 219), List(896, 70, 244, 460), List(943, 16, 568, 861), List(363, 626, 973, 297), List(397, 44, 92, 179), List(494, 337, 729, 899), List(750, 204, 840, 122), List(37, 69, 68, 202), List(452, 554, 248, 932), List(540, 205, 629, 908), List(756, 75, 973, 522), List(60, 376, 810, 889), List(351, 800, 930, 468), List(352, 38, 789, 921), List(929, 956, 909, 637), List(246, 782, 974, 862), List(495, 271, 475, 792), List(106, 937, 243, 893), List(922, 373, 956, 174), List(177, 888, 611, 889), List(963, 900, 153, 746), List(395, 241, 550, 511), List(202, 381, 700, 813), List(471, 848, 331, 233), List(299, 516, 910, 497), List(293, 893, 784, 818), List(773, 926, 287, 688), List(306, 905, 694, 439), List(682, 877, 886, 511), List(195, 345, 401, 347), List(271, 770, 84, 390), List(22, 618, 595, 346), List(71, 681, 146, 363), List(604, 486, 669, 940), List(980, 817, 838, 256), List(691, 613, 458, 474), List(820, 763, 708, 892), List(671, 452, 760, 971), List(654, 336, 997, 846), List(806, 950, 694, 859), List(309, 886, 76, 430), List(74, 739, 871, 749), List(510, 149, 846, 818), List(361, 518, 497, 330), List(586, 159, 975, 105), List(548, 662, 963, 595), List(856, 194, 657, 616)),949), List())
+  }
+
+  test("test6") {
+    assertEquals(Main.getGoodIndices(List(List(81, 172, 816, 189), List(809, 835, 516, 976), List(397, 971, 139, 93), List(681, 583, 211, 893), List(280, 14, 944, 299), List(376, 487, 547, 109), List(967, 509, 844, 522), List(50, 465, 477, 439), List(816, 204, 858, 24), List(909, 456, 252, 478), List(696, 242, 935, 324), List(917, 999, 174, 120), List(852, 237, 834, 506), List(296, 5, 111, 748), List(706, 607, 470, 176), List(511, 3, 181, 780), List(104, 121, 815, 559), List(30, 888, 987, 809), List(980, 646, 68, 621), List(151, 159, 847, 511), List(216, 153, 524, 81), List(232, 344, 443, 608), List(613, 48, 987, 567), List(482, 734, 352, 296), List(150, 54, 779, 387), List(53, 208, 939, 212), List(999, 667, 907, 712), List(527, 974, 693, 275), List(589, 415, 593, 251), List(817, 108, 592, 653), List(925, 383, 642, 863), List(409, 263, 441, 288), List(524, 586, 918, 266), List(248, 923, 220, 764), List(936, 616, 521, 106), List(599, 688, 72, 819), List(762, 876, 429, 494), List(353, 724, 774, 394), List(449, 376, 358, 861), List(223, 743, 609, 507), List(279, 890, 182, 381), List(407, 227, 318, 292), List(282, 543, 533, 892), List(821, 464, 352, 213), List(294, 289, 509, 759)),957), List())
+  }
+
+  test("test7") {
+    assertEquals(Main.getGoodIndices(List(List(6, 114, 977, 509), List(992, 896, 940, 360), List(108, 232, 245, 708), List(839, 994, 876, 132), List(322, 274, 923, 515), List(269, 439, 946, 817), List(495, 776, 365, 373), List(28, 782, 83, 118), List(979, 942, 907, 111), List(332, 664, 757, 833), List(885, 939, 68, 113), List(100, 104, 441, 578), List(769, 192, 680, 494), List(169, 51, 884, 261), List(88, 60, 678, 51), List(600, 260, 945, 893), List(578, 223, 333, 561), List(209, 752, 843, 166), List(880, 569, 698, 597), List(329, 525, 407, 1), List(431, 192, 711, 50), List(37, 855, 590, 473), List(935, 795, 85, 290), List(674, 556, 171, 211), List(825, 850, 418, 517), List(555, 737, 950, 132), List(405, 203, 554, 263), List(359, 170, 215, 258), List(381, 593, 785, 679), List(153, 704, 754, 957), List(919, 758, 73, 131), List(209, 121, 633, 452), List(850, 903, 831, 189), List(756, 405, 232, 235), List(254, 574, 70, 107), List(985, 221, 949, 601), List(671, 449, 108, 913), List(290, 917, 148, 391), List(871, 77, 224, 852), List(7, 41, 760, 862), List(205, 212, 549, 576), List(791, 683, 877, 501), List(128, 808, 94, 594), List(684, 588, 547, 118), List(708, 724, 428, 997), List(1, 515, 617, 413), List(689, 970, 677, 288), List(796, 841, 983, 774), List(854, 842, 649, 972), List(318, 13, 692, 791), List(514, 801, 601, 835), List(431, 810, 912, 183), List(778, 552, 326, 620), List(627, 343, 412, 901), List(380, 264, 962, 825), List(72, 869, 314, 356), List(479, 701, 720, 380), List(23, 52, 949, 882), List(67, 648, 120, 709), List(814, 251, 484, 453), List(482, 903, 374, 308), List(215, 393, 68, 708), List(432, 689, 907, 548), List(857, 652, 902, 652), List(421, 413, 237, 5), List(182, 165, 186, 942), List(314, 622, 884, 857), List(202, 236, 606, 575), List(564, 55, 87, 474), List(19, 759, 536, 282), List(796, 1000, 689, 798), List(484, 868, 402, 964), List(272, 713, 258, 838), List(523, 957, 746, 397), List(665, 948, 815, 727), List(267, 594, 16, 190), List(969, 604, 257, 608), List(985, 956, 429, 633), List(916, 717, 532, 947), List(701, 731, 143, 346), List(541, 175, 216, 703), List(557, 223, 184, 755), List(641, 243, 833, 33), List(217, 317, 296, 763), List(608, 874, 70, 716), List(392, 976, 115, 953), List(209, 461, 42, 352)),183), List())
+  }
+
+  test("test8") {
+    assertEquals(Main.getGoodIndices(List(List(856, 748, 650, 124), List(599, 74, 954, 720), List(116, 112, 187, 459), List(428, 787, 42, 243), List(878, 169, 977, 267), List(351, 952, 826, 534), List(730, 760, 533, 507), List(612, 167, 208, 56), List(349, 752, 126, 743), List(33, 575, 257, 955), List(815, 571, 494, 987), List(88, 322, 785, 329), List(892, 795, 384, 496), List(797, 873, 848, 768)),407), List())
+  }
+
+  test("test9") {
+    assertEquals(Main.getGoodIndices(List(List(14, 878, 402, 407), List(119, 107, 486, 233), List(125, 80, 792, 504), List(736, 647, 638, 163), List(327, 465, 694, 681), List(211, 281, 165, 386), List(367, 201, 826, 849), List(863, 520, 722, 684), List(355, 609, 311, 798), List(834, 455, 902, 854), List(588, 90, 135, 391), List(413, 824, 59, 558), List(893, 549, 420, 899), List(75, 689, 403, 773), List(903, 451, 775, 882), List(355, 597, 223, 600), List(494, 613, 819, 216), List(52, 966, 966, 121), List(70, 721, 779, 47), List(865, 606, 604, 472), List(110, 628, 751, 123), List(692, 72, 982, 58), List(205, 640, 791, 422), List(984, 652, 511, 224), List(806, 180, 445, 995), List(430, 603, 598, 48), List(175, 699, 700, 602), List(661, 825, 406, 892), List(58, 849, 434, 798), List(870, 146, 948, 823), List(512, 134, 216, 352), List(610, 137, 125, 97), List(711, 349, 103, 414), List(895, 440, 653, 260), List(609, 264, 3, 300), List(981, 577, 365, 681), List(41, 406, 773, 688), List(222, 359, 450, 29), List(354, 776, 679, 773), List(975, 931, 142, 736), List(135, 272, 914, 855), List(883, 967, 239, 928), List(900, 735, 587, 120), List(515, 421, 809, 961), List(863, 68, 310, 33), List(709, 487, 972, 559), List(132, 211, 686, 644), List(828, 944, 653, 544), List(17, 341, 781, 214), List(187, 271, 354, 656), List(1, 46, 897, 685), List(549, 945, 952, 120), List(535, 745, 438, 286), List(348, 781, 265, 119), List(627, 854, 993, 633), List(21, 273, 451, 965), List(346, 260, 623, 616), List(9, 152, 906, 545), List(455, 37, 410, 650), List(300, 571, 685, 624), List(982, 9, 26, 748)),169), List())
+  }
+
+}

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

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

earliest_possible_day_of_full_bloom/meta.json

@@ -0,0 +1,31 @@
+{
+    "id": 2257,
+    "name": "earliest_possible_day_of_full_bloom",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/earliest-possible-day-of-full-bloom/",
+    "date": "1641081600000",
+    "task_description": "You have `n` flower seeds. Every seed must be planted first before it can begin to grow, then bloom. Planting a seed takes time and so does the growth of a seed. You are given two **0-indexed** integer arrays `plantTime` and `growTime`, of length `n` each: `plantTime[i]` is the number of **full days** it takes you to **plant** the `ith` seed. Every day, you can work on planting exactly one seed. You **do not** have to work on planting the same seed on consecutive days, but the planting of a seed is not complete **until** you have worked `plantTime[i]` days on planting it in total. `growTime[i]` is the number of **full days** it takes the `ith` seed to grow after being completely planted. **After** the last day of its growth, the flower **blooms** and stays bloomed forever. From the beginning of day `0`, you can plant the seeds in **any** order. Return _the **earliest** possible day where **all** seeds are blooming_. **Example 1:** ``` **Input:** plantTime = [1,4,3], growTime = [2,3,1] **Output:** 9 **Explanation:** The grayed out pots represent planting days, colored pots represent growing days, and the flower represents the day it blooms. One optimal way is: On day 0, plant the 0th seed. The seed grows for 2 full days and blooms on day 3. On days 1, 2, 3, and 4, plant the 1st seed. The seed grows for 3 full days and blooms on day 8. On days 5, 6, and 7, plant the 2nd seed. The seed grows for 1 full day and blooms on day 9. Thus, on day 9, all the seeds are blooming. ``` **Example 2:** ``` **Input:** plantTime = [1,2,3,2], growTime = [2,1,2,1] **Output:** 9 **Explanation:** The grayed out pots represent planting days, colored pots represent growing days, and the flower represents the day it blooms. One optimal way is: On day 1, plant the 0th seed. The seed grows for 2 full days and blooms on day 4. On days 0 and 3, plant the 1st seed. The seed grows for 1 full day and blooms on day 5. On days 2, 4, and 5, plant the 2nd seed. The seed grows for 2 full days and blooms on day 8. On days 6 and 7, plant the 3rd seed. The seed grows for 1 full day and blooms on day 9. Thus, on day 9, all the seeds are blooming. ``` **Example 3:** ``` **Input:** plantTime = [1], growTime = [1] **Output:** 2 **Explanation:** On day 0, plant the 0th seed. The seed grows for 1 full day and blooms on day 2. Thus, on day 2, all the seeds are blooming. ``` **Constraints:** `n == plantTime.length == growTime.length` `1 <= n <= 105` `1 <= plantTime[i], growTime[i] <= 104`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "plantTime = [1,4,3], growTime = [2,3,1]",
+            "output": "9 "
+        },
+        {
+            "label": "Example 2",
+            "input": "plantTime = [1,2,3,2], growTime = [2,1,2,1]",
+            "output": "9 "
+        },
+        {
+            "label": "Example 3",
+            "input": "plantTime = [1], growTime = [1]",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "earliestFullBloom :: [Int] -> [Int] -> Int\nearliestFullBloom plantTime growTime ",
+    "ocaml_template": "let earliestFullBloom (plantTime: int list) (growTime: int list) : int =  ",
+    "scala_template": "def earliestFullBloom(plantTime: List[Int],growTime: List[Int]): Int = { \n    \n}",
+    "java_template": "public static int earliestFullBloom(List<Integer> plantTime, List<Integer> growTime) {\n\n}",
+    "python_template": "class Solution(object):\n    def earliestFullBloom(self, plantTime, growTime):\n        \"\"\"\n        :type plantTime: List[int]\n        :type growTime: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

earliest_possible_day_of_full_bloom/ocaml_tests/main.ml

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

earliest_possible_day_of_full_bloom/scala_tests/MySuite.scala

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

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

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

eat_pizzas/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(14, maxWeight(Arrays.asList(1,2,3,4,5,6,7,8)));
+}
+@Test
+public void test2() {
+    assertEquals(3, maxWeight(Arrays.asList(2,1,1,1,1,1,1,1)));
+}
+
+}

eat_pizzas/meta.json

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

equal_row_and_column_pairs/haskell_tests/Main.hs

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

equal_row_and_column_pairs/java_tests/Main.java

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