f1e59e39e1d69ee71db2a85629dc85fe001b219003101e627766b07b932f3ef2

.gitattributes

@@ -262,3 +262,4 @@ paint_house_iv/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
 paint_house_iv/meta.json filter=lfs diff=lfs merge=lfs -text
 partition_array_according_to_given_pivot/meta.json filter=lfs diff=lfs merge=lfs -text
 partition_array_such_that_maximum_difference_is_k/meta.json filter=lfs diff=lfs merge=lfs -text
+paths_in_matrix_whose_sum_is_divisible_by_k/meta.json filter=lfs diff=lfs merge=lfs -text

pass_the_pillow/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.passThePillow(4,5), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.passThePillow(3,2), 3)
+  }
+
+  test("test3") {
+    assertEquals(Main.passThePillow(724,598), 599)
+  }
+
+  test("test4") {
+    assertEquals(Main.passThePillow(977,319), 320)
+  }
+
+  test("test5") {
+    assertEquals(Main.passThePillow(638,481), 482)
+  }
+
+  test("test6") {
+    assertEquals(Main.passThePillow(436,189), 190)
+  }
+
+  test("test7") {
+    assertEquals(Main.passThePillow(31,202), 23)
+  }
+
+  test("test8") {
+    assertEquals(Main.passThePillow(603,872), 333)
+  }
+
+  test("test9") {
+    assertEquals(Main.passThePillow(952,39), 40)
+  }
+
+  test("test10") {
+    assertEquals(Main.passThePillow(440,944), 67)
+  }
+
+}

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

paths_in_matrix_whose_sum_is_divisible_by_k/java_tests/Main.java

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

paths_in_matrix_whose_sum_is_divisible_by_k/meta.json

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

paths_in_matrix_whose_sum_is_divisible_by_k/ocaml_tests/main.ml

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

paths_in_matrix_whose_sum_is_divisible_by_k/scala_tests/MySuite.scala

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

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

percentage_of_letter_in_string/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 (percentageLetter \"foobar \"  \"o \")," 33 (percentageLetter "foobar" "o"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (percentageLetter \"jjjj \"  \"k \")," 0 (percentageLetter "jjjj" "k"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (percentageLetter  \"wunhzwrjvktyvtwnajowktljoivxzxjbxvceubyspqhfgwpkltiryvkdnvpmqjgaphxmtnhlp \"  \"q \")," 2 (percentageLetter "wunhzwrjvktyvtwnajowktljoivxzxjbxvceubyspqhfgwpkltiryvkdnvpmqjgaphxmtnhlp" "q"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (percentageLetter  \"kaewjzoeuyxfjhfstddrnkggyybjbfrqwdbeyujziihauxz \"  \"h \")," 4 (percentageLetter "kaewjzoeuyxfjhfstddrnkggyybjbfrqwdbeyujziihauxz" "h"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (percentageLetter  \"hwygxifdszmbggg \"  \"f \")," 6 (percentageLetter "hwygxifdszmbggg" "f"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (percentageLetter  \"znzhbbydpicffusltzanttilxmdjrxmmkoiustdoepiaaxgzquvkvlhwdywvbjcdyhdwhsdej \"  \"h \")," 5 (percentageLetter "znzhbbydpicffusltzanttilxmdjrxmmkoiustdoepiaaxgzquvkvlhwdywvbjcdyhdwhsdej" "h"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (percentageLetter  \"rwcri \"  \"p \")," 0 (percentageLetter "rwcri" "p"))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (percentageLetter  \"kpnwpskycejr \"  \"r \")," 8 (percentageLetter "kpnwpskycejr" "r"))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (percentageLetter  \"ciphjsblwpcnyirqkxbvvpcvigvxfzorutqonwhguqvypexxxjavwbgjwy \"  \"u \")," 3 (percentageLetter "ciphjsblwpcnyirqkxbvvpcvigvxfzorutqonwhguqvypexxxjavwbgjwy" "u"))
+
+
+-- 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

percentage_of_letter_in_string/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(33, percentageLetter("foobar", "o"));
+}
+@Test
+public void test2() {
+    assertEquals(0, percentageLetter("jjjj", "k"));
+}
+
+}

percentage_of_letter_in_string/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 2365,
+    "name": "percentage_of_letter_in_string",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/percentage-of-letter-in-string/",
+    "date": "2022-05-15 00:00:00",
+    "task_description": "Given a string `s` and a character `letter`, return_ the **percentage** of characters in _`s`_ that equal _`letter`_ **rounded down** to the nearest whole percent._ **Example 1:** ``` **Input:** s = \"foobar\", letter = \"o\" **Output:** 33 **Explanation:** The percentage of characters in s that equal the letter 'o' is 2 / 6 * 100% = 33% when rounded down, so we return 33. ``` **Example 2:** ``` **Input:** s = \"jjjj\", letter = \"k\" **Output:** 0 **Explanation:** The percentage of characters in s that equal the letter 'k' is 0%, so we return 0. ``` **Constraints:** `1 <= s.length <= 100` `s` consists of lowercase English letters. `letter` is a lowercase English letter.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"foobar\", letter = \"o\"",
+            "output": "33 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"jjjj\", letter = \"k\"",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"wunhzwrjvktyvtwnajowktljoivxzxjbxvceubyspqhfgwpkltiryvkdnvpmqjgaphxmtnhlp\"",
+                "\"q\""
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                "\"kaewjzoeuyxfjhfstddrnkggyybjbfrqwdbeyujziihauxz\"",
+                "\"h\""
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                "\"hwygxifdszmbggg\"",
+                "\"f\""
+            ],
+            "output": 6
+        },
+        {
+            "input": [
+                "\"znzhbbydpicffusltzanttilxmdjrxmmkoiustdoepiaaxgzquvkvlhwdywvbjcdyhdwhsdej\"",
+                "\"h\""
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                "\"rwcri\"",
+                "\"p\""
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "\"kpnwpskycejr\"",
+                "\"r\""
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                "\"ciphjsblwpcnyirqkxbvvpcvigvxfzorutqonwhguqvypexxxjavwbgjwy\"",
+                "\"u\""
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                "\"cxduxmihlqmoxrjqabjnfylhalqpgadmsmklrpxqafndkiztdzpgwgueswwwudmbbwmmtt\"",
+                "\"x\""
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                "fxxhjdndkkfkovsolzgyfmvwfqpzqiiutsstfgidwi",
+                "u"
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                "ipklocivwszbhosxllbbppgkc",
+                "c"
+            ],
+            "output": 8
+        }
+    ],
+    "haskell_template": "percentageLetter :: String -> String -> Int\npercentageLetter s letter ",
+    "ocaml_template": "let percentageLetter (s: string) (letter: string) : int =  ",
+    "scala_template": "def percentageLetter(s: String,letter: String): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int percentageLetter(String s, char letter) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def percentageLetter(self, s, letter):\n        \"\"\"\n        :type s: str\n        :type letter: str\n        :rtype: int\n        \"\"\"\n        "
+}

percentage_of_letter_in_string/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 33 (percentageLetter "foobar" "o")
+
+let test2 _ = assert_equal 0 (percentageLetter "jjjj" "k")
+
+let test3 _ = assert_equal 2 (percentageLetter "wunhzwrjvktyvtwnajowktljoivxzxjbxvceubyspqhfgwpkltiryvkdnvpmqjgaphxmtnhlp" "q")
+
+let test4 _ = assert_equal 4 (percentageLetter "kaewjzoeuyxfjhfstddrnkggyybjbfrqwdbeyujziihauxz" "h")
+
+let test5 _ = assert_equal 6 (percentageLetter "hwygxifdszmbggg" "f")
+
+let test6 _ = assert_equal 5 (percentageLetter "znzhbbydpicffusltzanttilxmdjrxmmkoiustdoepiaaxgzquvkvlhwdywvbjcdyhdwhsdej" "h")
+
+let test7 _ = assert_equal 0 (percentageLetter "rwcri" "p")
+
+let test8 _ = assert_equal 8 (percentageLetter "kpnwpskycejr" "r")
+
+let test9 _ = assert_equal 3 (percentageLetter "ciphjsblwpcnyirqkxbvvpcvigvxfzorutqonwhguqvypexxxjavwbgjwy" "u")
+
+let test10 _ = assert_equal 5 (percentageLetter "cxduxmihlqmoxrjqabjnfylhalqpgadmsmklrpxqafndkiztdzpgwgueswwwudmbbwmmtt" "x")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for percentageLetter" >::: [
+        
+  "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

percentage_of_letter_in_string/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.percentageLetter("foobar","o"), 33)
+  }
+
+  test("test2") {
+    assertEquals(Main.percentageLetter("jjjj","k"), 0)
+  }
+
+  test("test3") {
+    assertEquals(Main.percentageLetter("wunhzwrjvktyvtwnajowktljoivxzxjbxvceubyspqhfgwpkltiryvkdnvpmqjgaphxmtnhlp","q"), 2)
+  }
+
+  test("test4") {
+    assertEquals(Main.percentageLetter("kaewjzoeuyxfjhfstddrnkggyybjbfrqwdbeyujziihauxz","h"), 4)
+  }
+
+  test("test5") {
+    assertEquals(Main.percentageLetter("hwygxifdszmbggg","f"), 6)
+  }
+
+  test("test6") {
+    assertEquals(Main.percentageLetter("znzhbbydpicffusltzanttilxmdjrxmmkoiustdoepiaaxgzquvkvlhwdywvbjcdyhdwhsdej","h"), 5)
+  }
+
+  test("test7") {
+    assertEquals(Main.percentageLetter("rwcri","p"), 0)
+  }
+
+  test("test8") {
+    assertEquals(Main.percentageLetter("kpnwpskycejr","r"), 8)
+  }
+
+  test("test9") {
+    assertEquals(Main.percentageLetter("ciphjsblwpcnyirqkxbvvpcvigvxfzorutqonwhguqvypexxxjavwbgjwy","u"), 3)
+  }
+
+  test("test10") {
+    assertEquals(Main.percentageLetter("cxduxmihlqmoxrjqabjnfylhalqpgadmsmklrpxqafndkiztdzpgwgueswwwudmbbwmmtt","x"), 5)
+  }
+
+}

permutation_difference_between_two_strings/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 (findPermutationDifference \"abc \"  \"bac \")," 2 (findPermutationDifference "abc" "bac"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findPermutationDifference \"abcde \"  \"edbac \")," 12 (findPermutationDifference "abcde" "edbac"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (findPermutationDifference  \"ovmuxe \"  \"umevxo \")," 14 (findPermutationDifference "ovmuxe" "umevxo"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (findPermutationDifference  \"jeqiopgvdkm \"  \"jikpomeqgvd \")," 32 (findPermutationDifference "jeqiopgvdkm" "jikpomeqgvd"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (findPermutationDifference  \"kmrycdgajlwiouzqsnex \"  \"nyzqorgwmxcdlesujiak \")," 142 (findPermutationDifference "kmrycdgajlwiouzqsnex" "nyzqorgwmxcdlesujiak"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (findPermutationDifference  \"ulpgofezvtrdmjsaynx \"  \"yfteunlvxdsjzgamorp \")," 124 (findPermutationDifference "ulpgofezvtrdmjsaynx" "yfteunlvxdsjzgamorp"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (findPermutationDifference  \"tqenyijdapoxfkmwvzrchlu \"  \"velicpqzfjhrkydamwxuton \")," 184 (findPermutationDifference "tqenyijdapoxfkmwvzrchlu" "velicpqzfjhrkydamwxuton"))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (findPermutationDifference  \"cdv \"  \"cdv \")," 0 (findPermutationDifference "cdv" "cdv"))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (findPermutationDifference  \"uacxvrdlmtwgybpshjfnqiz \"  \"yazjiuqgpvshncfdtxwmbrl \")," 216 (findPermutationDifference "uacxvrdlmtwgybpshjfnqiz" "yazjiuqgpvshncfdtxwmbrl"))
+
+
+-- 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

permutation_difference_between_two_strings/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(2, findPermutationDifference("abc", "bac"));
+}
+@Test
+public void test2() {
+    assertEquals(12, findPermutationDifference("abcde", "edbac"));
+}
+
+}

permutation_difference_between_two_strings/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3412,
+    "name": "permutation_difference_between_two_strings",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/permutation-difference-between-two-strings/",
+    "date": "2024-05-05 00:00:00",
+    "task_description": "You are given two strings `s` and `t` such that every character occurs at most once in `s` and `t` is a permutation of `s`. The **permutation difference** between `s` and `t` is defined as the **sum** of the absolute difference between the index of the occurrence of each character in `s` and the index of the occurrence of the same character in `t`. Return the **permutation difference** between `s` and `t`. **Example 1:** **Input:** s = \"abc\", t = \"bac\" **Output:** 2 **Explanation:** For `s = \"abc\"` and `t = \"bac\"`, the permutation difference of `s` and `t` is equal to the sum of: The absolute difference between the index of the occurrence of `\"a\"` in `s` and the index of the occurrence of `\"a\"` in `t`. The absolute difference between the index of the occurrence of `\"b\"` in `s` and the index of the occurrence of `\"b\"` in `t`. The absolute difference between the index of the occurrence of `\"c\"` in `s` and the index of the occurrence of `\"c\"` in `t`. That is, the permutation difference between `s` and `t` is equal to `|0 - 1| + |1 - 0| + |2 - 2| = 2`. **Example 2:** **Input:** s = \"abcde\", t = \"edbac\" **Output:** 12 **Explanation:** The permutation difference between `s` and `t` is equal to `|0 - 3| + |1 - 2| + |2 - 4| + |3 - 1| + |4 - 0| = 12`. **Constraints:** `1 <= s.length <= 26` Each character occurs at most once in `s`. `t` is a permutation of `s`. `s` consists only of lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"abc\", t = \"bac\"",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"abcde\", t = \"edbac\"",
+            "output": "12 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"ovmuxe\"",
+                "\"umevxo\""
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                "\"jeqiopgvdkm\"",
+                "\"jikpomeqgvd\""
+            ],
+            "output": 32
+        },
+        {
+            "input": [
+                "\"kmrycdgajlwiouzqsnex\"",
+                "\"nyzqorgwmxcdlesujiak\""
+            ],
+            "output": 142
+        },
+        {
+            "input": [
+                "\"ulpgofezvtrdmjsaynx\"",
+                "\"yfteunlvxdsjzgamorp\""
+            ],
+            "output": 124
+        },
+        {
+            "input": [
+                "\"tqenyijdapoxfkmwvzrchlu\"",
+                "\"velicpqzfjhrkydamwxuton\""
+            ],
+            "output": 184
+        },
+        {
+            "input": [
+                "\"cdv\"",
+                "\"cdv\""
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "\"uacxvrdlmtwgybpshjfnqiz\"",
+                "\"yazjiuqgpvshncfdtxwmbrl\""
+            ],
+            "output": 216
+        },
+        {
+            "input": [
+                "\"gteqpfdyuail\"",
+                "\"aytgfudleqip\""
+            ],
+            "output": 46
+        },
+        {
+            "input": [
+                "ajfbiwcxsudznghrlqyovpktm",
+                "dtzbrspfhavgmnuxcqlkwjoyi"
+            ],
+            "output": 206
+        },
+        {
+            "input": [
+                "gfbkolwtcimqp",
+                "fcpobkwqitgml"
+            ],
+            "output": 48
+        }
+    ],
+    "haskell_template": "findPermutationDifference :: String -> String -> Int\nfindPermutationDifference s t ",
+    "ocaml_template": "let findPermutationDifference (s: string) (t: string) : int =  ",
+    "scala_template": "def findPermutationDifference(s: String,t: String): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int findPermutationDifference(String s, String t) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findPermutationDifference(self, s, t):\n        \"\"\"\n        :type s: str\n        :type t: str\n        :rtype: int\n        \"\"\"\n        "
+}

permutation_difference_between_two_strings/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (findPermutationDifference "abc" "bac")
+
+let test2 _ = assert_equal 12 (findPermutationDifference "abcde" "edbac")
+
+let test3 _ = assert_equal 14 (findPermutationDifference "ovmuxe" "umevxo")
+
+let test4 _ = assert_equal 32 (findPermutationDifference "jeqiopgvdkm" "jikpomeqgvd")
+
+let test5 _ = assert_equal 142 (findPermutationDifference "kmrycdgajlwiouzqsnex" "nyzqorgwmxcdlesujiak")
+
+let test6 _ = assert_equal 124 (findPermutationDifference "ulpgofezvtrdmjsaynx" "yfteunlvxdsjzgamorp")
+
+let test7 _ = assert_equal 184 (findPermutationDifference "tqenyijdapoxfkmwvzrchlu" "velicpqzfjhrkydamwxuton")
+
+let test8 _ = assert_equal 0 (findPermutationDifference "cdv" "cdv")
+
+let test9 _ = assert_equal 216 (findPermutationDifference "uacxvrdlmtwgybpshjfnqiz" "yazjiuqgpvshncfdtxwmbrl")
+
+let test10 _ = assert_equal 46 (findPermutationDifference "gteqpfdyuail" "aytgfudleqip")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for findPermutationDifference" >::: [
+        
+  "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

permutation_difference_between_two_strings/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findPermutationDifference("abc","bac"), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.findPermutationDifference("abcde","edbac"), 12)
+  }
+
+  test("test3") {
+    assertEquals(Main.findPermutationDifference("ovmuxe","umevxo"), 14)
+  }
+
+  test("test4") {
+    assertEquals(Main.findPermutationDifference("jeqiopgvdkm","jikpomeqgvd"), 32)
+  }
+
+  test("test5") {
+    assertEquals(Main.findPermutationDifference("kmrycdgajlwiouzqsnex","nyzqorgwmxcdlesujiak"), 142)
+  }
+
+  test("test6") {
+    assertEquals(Main.findPermutationDifference("ulpgofezvtrdmjsaynx","yfteunlvxdsjzgamorp"), 124)
+  }
+
+  test("test7") {
+    assertEquals(Main.findPermutationDifference("tqenyijdapoxfkmwvzrchlu","velicpqzfjhrkydamwxuton"), 184)
+  }
+
+  test("test8") {
+    assertEquals(Main.findPermutationDifference("cdv","cdv"), 0)
+  }
+
+  test("test9") {
+    assertEquals(Main.findPermutationDifference("uacxvrdlmtwgybpshjfnqiz","yazjiuqgpvshncfdtxwmbrl"), 216)
+  }
+
+  test("test10") {
+    assertEquals(Main.findPermutationDifference("gteqpfdyuail","aytgfudleqip"), 46)
+  }
+
+}

permutations_iv/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 (permute 4 6)," [3,4,1,2] (permute 4 6))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (permute 3 2)," [3,2,1] (permute 3 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (permute 2 3)," [] (permute 2 3))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (permute 40 635429710889172)," [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,27,28,23,32,31,26,35,36,39,40,19,34,21,38,37,20,33,30,29,24,25,22] (permute 40 635429710889172))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (permute 90 518738247805590)," [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,75,82,77,90,73,88,83,86,71,84,79,70,89,78,85,74,81,76,69,80,87,72] (permute 90 518738247805590))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (permute 1 40295860898402)," [] (permute 1 40295860898402))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (permute 16 349551818813564)," [] (permute 16 349551818813564))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (permute 87 998153691720678)," [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,78,85,84,67,66,75,68,73,72,71,74,77,82,81,86,79,76,83,70,87,80,69] (permute 87 998153691720678))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (permute 74 795093009177573)," [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,63,64,59,70,73,72,65,68,67,62,61,74,71,66,69,60,53,58,55,54,57,56] (permute 74 795093009177573))
+
+
+-- 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

permutations_iv/java_tests/Main.java

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

permutations_iv/meta.json

@@ -0,0 +1,538 @@
+{
+    "id": 3783,
+    "name": "permutations_iv",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/permutations-iv/",
+    "date": "2025-02-15 00:00:00",
+    "task_description": "Given two integers, `n` and `k`, an **alternating permutation** is a permutation of the first `n` positive integers such that no **two** adjacent elements are both odd or both even. Return the **k-th** **alternating permutation** sorted in _lexicographical order_. If there are fewer than `k` valid **alternating permutations**, return an empty list. **Example 1:** **Input:** n = 4, k = 6 **Output:** [3,4,1,2] **Explanation:** The lexicographically-sorted alternating permutations of `[1, 2, 3, 4]` are: `[1, 2, 3, 4]` `[1, 4, 3, 2]` `[2, 1, 4, 3]` `[2, 3, 4, 1]` `[3, 2, 1, 4]` `[3, 4, 1, 2]` ← 6th permutation `[4, 1, 2, 3]` `[4, 3, 2, 1]` Since `k = 6`, we return `[3, 4, 1, 2]`. **Example 2:** **Input:** n = 3, k = 2 **Output:** [3,2,1] **Explanation:** The lexicographically-sorted alternating permutations of `[1, 2, 3]` are: `[1, 2, 3]` `[3, 2, 1]` ← 2nd permutation Since `k = 2`, we return `[3, 2, 1]`. **Example 3:** **Input:** n = 2, k = 3 **Output:** [] **Explanation:** The lexicographically-sorted alternating permutations of `[1, 2]` are: `[1, 2]` `[2, 1]` There are only 2 alternating permutations, but `k = 3`, which is out of range. Thus, we return an empty list `[]`. **Constraints:** `1 <= n <= 100` `1 <= k <= 1015`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 4, k = 6",
+            "output": "[3,4,1,2] "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 3, k = 2",
+            "output": "[3,2,1] "
+        },
+        {
+            "label": "Example 3",
+            "input": "n = 2, k = 3",
+            "output": "[] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                40,
+                635429710889172
+            ],
+            "output": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                27,
+                28,
+                23,
+                32,
+                31,
+                26,
+                35,
+                36,
+                39,
+                40,
+                19,
+                34,
+                21,
+                38,
+                37,
+                20,
+                33,
+                30,
+                29,
+                24,
+                25,
+                22
+            ]
+        },
+        {
+            "input": [
+                90,
+                518738247805590
+            ],
+            "output": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+                21,
+                22,
+                23,
+                24,
+                25,
+                26,
+                27,
+                28,
+                29,
+                30,
+                31,
+                32,
+                33,
+                34,
+                35,
+                36,
+                37,
+                38,
+                39,
+                40,
+                41,
+                42,
+                43,
+                44,
+                45,
+                46,
+                47,
+                48,
+                49,
+                50,
+                51,
+                52,
+                53,
+                54,
+                55,
+                56,
+                57,
+                58,
+                59,
+                60,
+                61,
+                62,
+                63,
+                64,
+                65,
+                66,
+                67,
+                68,
+                75,
+                82,
+                77,
+                90,
+                73,
+                88,
+                83,
+                86,
+                71,
+                84,
+                79,
+                70,
+                89,
+                78,
+                85,
+                74,
+                81,
+                76,
+                69,
+                80,
+                87,
+                72
+            ]
+        },
+        {
+            "input": [
+                1,
+                40295860898402
+            ],
+            "output": []
+        },
+        {
+            "input": [
+                16,
+                349551818813564
+            ],
+            "output": []
+        },
+        {
+            "input": [
+                87,
+                998153691720678
+            ],
+            "output": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+                21,
+                22,
+                23,
+                24,
+                25,
+                26,
+                27,
+                28,
+                29,
+                30,
+                31,
+                32,
+                33,
+                34,
+                35,
+                36,
+                37,
+                38,
+                39,
+                40,
+                41,
+                42,
+                43,
+                44,
+                45,
+                46,
+                47,
+                48,
+                49,
+                50,
+                51,
+                52,
+                53,
+                54,
+                55,
+                56,
+                57,
+                58,
+                59,
+                60,
+                61,
+                62,
+                63,
+                64,
+                65,
+                78,
+                85,
+                84,
+                67,
+                66,
+                75,
+                68,
+                73,
+                72,
+                71,
+                74,
+                77,
+                82,
+                81,
+                86,
+                79,
+                76,
+                83,
+                70,
+                87,
+                80,
+                69
+            ]
+        },
+        {
+            "input": [
+                74,
+                795093009177573
+            ],
+            "output": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+                21,
+                22,
+                23,
+                24,
+                25,
+                26,
+                27,
+                28,
+                29,
+                30,
+                31,
+                32,
+                33,
+                34,
+                35,
+                36,
+                37,
+                38,
+                39,
+                40,
+                41,
+                42,
+                43,
+                44,
+                45,
+                46,
+                47,
+                48,
+                49,
+                50,
+                51,
+                52,
+                63,
+                64,
+                59,
+                70,
+                73,
+                72,
+                65,
+                68,
+                67,
+                62,
+                61,
+                74,
+                71,
+                66,
+                69,
+                60,
+                53,
+                58,
+                55,
+                54,
+                57,
+                56
+            ]
+        },
+        {
+            "input": [
+                3,
+                331829499538853
+            ],
+            "output": []
+        },
+        {
+            "input": [
+                31,
+                738363147318413
+            ],
+            "output": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                20,
+                13,
+                10,
+                27,
+                14,
+                23,
+                12,
+                11,
+                18,
+                21,
+                28,
+                25,
+                26,
+                31,
+                22,
+                29,
+                24,
+                17,
+                16,
+                15,
+                30,
+                19
+            ]
+        },
+        {
+            "input": [
+                40,
+                699856856676228
+            ],
+            "output": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                27,
+                38,
+                21,
+                28,
+                35,
+                36,
+                19,
+                30,
+                23,
+                20,
+                37,
+                26,
+                31,
+                32,
+                39,
+                34,
+                25,
+                40,
+                33,
+                24,
+                29,
+                22
+            ]
+        },
+        {
+            "input": [
+                67,
+                674021944184663
+            ],
+            "output": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+                21,
+                22,
+                23,
+                24,
+                25,
+                26,
+                27,
+                28,
+                29,
+                30,
+                31,
+                32,
+                33,
+                34,
+                35,
+                36,
+                37,
+                38,
+                39,
+                40,
+                41,
+                42,
+                43,
+                44,
+                45,
+                54,
+                61,
+                48,
+                65,
+                60,
+                47,
+                58,
+                51,
+                56,
+                63,
+                62,
+                57,
+                50,
+                53,
+                64,
+                67,
+                46,
+                59,
+                66,
+                49,
+                52,
+                55
+            ]
+        }
+    ],
+    "haskell_template": "permute :: Int -> Int -> [Int]\npermute n k ",
+    "ocaml_template": "let permute (n: int) (k: int) : int list =  ",
+    "scala_template": "def permute(n: Int,k: Int): List[Int] = { \n    \n}",
+    "java_template": "class Solution {\n    public int[] permute(int n, long k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def permute(self, n, k):\n        \"\"\"\n        :type n: int\n        :type k: int\n        :rtype: List[int]\n        \"\"\"\n        "
+}

permutations_iv/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal [3;4;1;2] (permute 4 6)
+
+let test2 _ = assert_equal [3;2;1] (permute 3 2)
+
+let test3 _ = assert_equal [] (permute 2 3)
+
+let test4 _ = assert_equal [1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;27;28;23;32;31;26;35;36;39;40;19;34;21;38;37;20;33;30;29;24;25;22] (permute 40 635429710889172)
+
+let test5 _ = assert_equal [1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20;21;22;23;24;25;26;27;28;29;30;31;32;33;34;35;36;37;38;39;40;41;42;43;44;45;46;47;48;49;50;51;52;53;54;55;56;57;58;59;60;61;62;63;64;65;66;67;68;75;82;77;90;73;88;83;86;71;84;79;70;89;78;85;74;81;76;69;80;87;72] (permute 90 518738247805590)
+
+let test6 _ = assert_equal [] (permute 1 40295860898402)
+
+let test7 _ = assert_equal [] (permute 16 349551818813564)
+
+let test8 _ = assert_equal [1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20;21;22;23;24;25;26;27;28;29;30;31;32;33;34;35;36;37;38;39;40;41;42;43;44;45;46;47;48;49;50;51;52;53;54;55;56;57;58;59;60;61;62;63;64;65;78;85;84;67;66;75;68;73;72;71;74;77;82;81;86;79;76;83;70;87;80;69] (permute 87 998153691720678)
+
+let test9 _ = assert_equal [1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20;21;22;23;24;25;26;27;28;29;30;31;32;33;34;35;36;37;38;39;40;41;42;43;44;45;46;47;48;49;50;51;52;63;64;59;70;73;72;65;68;67;62;61;74;71;66;69;60;53;58;55;54;57;56] (permute 74 795093009177573)
+
+let test10 _ = assert_equal [] (permute 3 331829499538853)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for permute" >::: [
+        
+  "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

permutations_iv/scala_tests/MySuite.scala

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

points_that_intersect_with_cars/haskell_tests/Main.hs

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

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

points_that_intersect_with_cars/meta.json

@@ -0,0 +1,972 @@
+{
+    "id": 3034,
+    "name": "points_that_intersect_with_cars",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/points-that-intersect-with-cars/",
+    "date": "2023-09-03 00:00:00",
+    "task_description": "You are given a **0-indexed** 2D integer array `nums` representing the coordinates of the cars parking on a number line. For any index `i`, `nums[i] = [starti, endi]` where `starti` is the starting point of the `ith` car and `endi` is the ending point of the `ith` car. Return _the number of integer points on the line that are covered with **any part** of a car._ **Example 1:** ``` **Input:** nums = [[3,6],[1,5],[4,7]] **Output:** 7 **Explanation:** All the points from 1 to 7 intersect at least one car, therefore the answer would be 7. ``` **Example 2:** ``` **Input:** nums = [[1,3],[5,8]] **Output:** 7 **Explanation:** Points intersecting at least one car are 1, 2, 3, 5, 6, 7, 8. There are a total of 7 points, therefore the answer would be 7. ``` **Constraints:** `1 <= nums.length <= 100` `nums[i].length == 2` `1 <= starti <= endi <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [[3,6],[1,5],[4,7]]",
+            "output": "7 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [[1,3],[5,8]]",
+            "output": "7 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    1,
+                    100
+                ],
+                [
+                    2,
+                    11
+                ],
+                [
+                    3,
+                    89
+                ],
+                [
+                    4,
+                    44
+                ],
+                [
+                    10,
+                    44
+                ],
+                [
+                    10,
+                    56
+                ],
+                [
+                    11,
+                    95
+                ],
+                [
+                    13,
+                    13
+                ],
+                [
+                    16,
+                    96
+                ],
+                [
+                    20,
+                    73
+                ],
+                [
+                    22,
+                    38
+                ],
+                [
+                    25,
+                    76
+                ],
+                [
+                    26,
+                    98
+                ],
+                [
+                    27,
+                    59
+                ],
+                [
+                    27,
+                    87
+                ],
+                [
+                    27,
+                    100
+                ],
+                [
+                    28,
+                    32
+                ],
+                [
+                    30,
+                    51
+                ],
+                [
+                    32,
+                    67
+                ],
+                [
+                    32,
+                    74
+                ],
+                [
+                    33,
+                    49
+                ],
+                [
+                    37,
+                    41
+                ],
+                [
+                    37,
+                    89
+                ],
+                [
+                    43,
+                    58
+                ],
+                [
+                    44,
+                    46
+                ],
+                [
+                    52,
+                    96
+                ],
+                [
+                    53,
+                    86
+                ],
+                [
+                    56,
+                    99
+                ],
+                [
+                    60,
+                    69
+                ],
+                [
+                    61,
+                    96
+                ],
+                [
+                    64,
+                    97
+                ],
+                [
+                    67,
+                    87
+                ],
+                [
+                    71,
+                    99
+                ],
+                [
+                    75,
+                    80
+                ],
+                [
+                    75,
+                    91
+                ],
+                [
+                    77,
+                    92
+                ],
+                [
+                    86,
+                    96
+                ],
+                [
+                    89,
+                    99
+                ],
+                [
+                    89,
+                    100
+                ],
+                [
+                    92,
+                    100
+                ],
+                [
+                    93,
+                    94
+                ],
+                [
+                    97,
+                    98
+                ]
+            ],
+            "output": 100
+        },
+        {
+            "input": [
+                [
+                    1,
+                    100
+                ],
+                [
+                    1,
+                    79
+                ],
+                [
+                    3,
+                    32
+                ],
+                [
+                    6,
+                    24
+                ],
+                [
+                    7,
+                    41
+                ],
+                [
+                    8,
+                    81
+                ],
+                [
+                    9,
+                    54
+                ],
+                [
+                    11,
+                    30
+                ],
+                [
+                    11,
+                    80
+                ],
+                [
+                    20,
+                    99
+                ],
+                [
+                    21,
+                    66
+                ],
+                [
+                    23,
+                    45
+                ],
+                [
+                    24,
+                    27
+                ],
+                [
+                    26,
+                    55
+                ],
+                [
+                    27,
+                    93
+                ],
+                [
+                    29,
+                    90
+                ],
+                [
+                    30,
+                    75
+                ],
+                [
+                    31,
+                    57
+                ],
+                [
+                    31,
+                    63
+                ],
+                [
+                    32,
+                    73
+                ],
+                [
+                    36,
+                    49
+                ],
+                [
+                    36,
+                    81
+                ],
+                [
+                    36,
+                    86
+                ],
+                [
+                    37,
+                    52
+                ],
+                [
+                    37,
+                    56
+                ],
+                [
+                    37,
+                    73
+                ],
+                [
+                    40,
+                    71
+                ],
+                [
+                    41,
+                    42
+                ],
+                [
+                    41,
+                    52
+                ],
+                [
+                    42,
+                    84
+                ],
+                [
+                    44,
+                    82
+                ],
+                [
+                    45,
+                    99
+                ],
+                [
+                    46,
+                    53
+                ],
+                [
+                    47,
+                    66
+                ],
+                [
+                    47,
+                    66
+                ],
+                [
+                    48,
+                    72
+                ],
+                [
+                    49,
+                    55
+                ],
+                [
+                    50,
+                    52
+                ],
+                [
+                    50,
+                    74
+                ],
+                [
+                    51,
+                    62
+                ],
+                [
+                    53,
+                    68
+                ],
+                [
+                    53,
+                    83
+                ],
+                [
+                    55,
+                    55
+                ],
+                [
+                    55,
+                    83
+                ],
+                [
+                    56,
+                    66
+                ],
+                [
+                    56,
+                    84
+                ],
+                [
+                    58,
+                    91
+                ],
+                [
+                    62,
+                    86
+                ],
+                [
+                    63,
+                    80
+                ],
+                [
+                    64,
+                    84
+                ],
+                [
+                    64,
+                    97
+                ],
+                [
+                    65,
+                    82
+                ],
+                [
+                    67,
+                    78
+                ],
+                [
+                    68,
+                    73
+                ],
+                [
+                    68,
+                    86
+                ],
+                [
+                    69,
+                    98
+                ],
+                [
+                    70,
+                    95
+                ],
+                [
+                    70,
+                    100
+                ],
+                [
+                    71,
+                    86
+                ],
+                [
+                    72,
+                    72
+                ],
+                [
+                    72,
+                    77
+                ],
+                [
+                    72,
+                    87
+                ],
+                [
+                    73,
+                    87
+                ],
+                [
+                    73,
+                    89
+                ],
+                [
+                    73,
+                    93
+                ],
+                [
+                    75,
+                    87
+                ],
+                [
+                    78,
+                    82
+                ],
+                [
+                    79,
+                    79
+                ],
+                [
+                    81,
+                    86
+                ],
+                [
+                    82,
+                    94
+                ],
+                [
+                    82,
+                    95
+                ],
+                [
+                    83,
+                    95
+                ],
+                [
+                    85,
+                    98
+                ],
+                [
+                    91,
+                    95
+                ],
+                [
+                    93,
+                    99
+                ],
+                [
+                    93,
+                    100
+                ],
+                [
+                    94,
+                    98
+                ],
+                [
+                    97,
+                    97
+                ],
+                [
+                    97,
+                    100
+                ],
+                [
+                    99,
+                    99
+                ]
+            ],
+            "output": 100
+        },
+        {
+            "input": [
+                [
+                    13,
+                    98
+                ],
+                [
+                    16,
+                    27
+                ],
+                [
+                    17,
+                    90
+                ],
+                [
+                    21,
+                    32
+                ],
+                [
+                    24,
+                    96
+                ],
+                [
+                    34,
+                    40
+                ],
+                [
+                    34,
+                    73
+                ],
+                [
+                    47,
+                    82
+                ],
+                [
+                    48,
+                    82
+                ],
+                [
+                    51,
+                    90
+                ],
+                [
+                    55,
+                    84
+                ],
+                [
+                    71,
+                    76
+                ],
+                [
+                    72,
+                    85
+                ],
+                [
+                    73,
+                    97
+                ],
+                [
+                    79,
+                    93
+                ],
+                [
+                    80,
+                    97
+                ],
+                [
+                    82,
+                    83
+                ],
+                [
+                    87,
+                    95
+                ],
+                [
+                    96,
+                    98
+                ]
+            ],
+            "output": 86
+        },
+        {
+            "input": [
+                [
+                    2,
+                    100
+                ],
+                [
+                    6,
+                    53
+                ],
+                [
+                    6,
+                    78
+                ],
+                [
+                    7,
+                    45
+                ],
+                [
+                    9,
+                    16
+                ],
+                [
+                    11,
+                    63
+                ],
+                [
+                    11,
+                    73
+                ],
+                [
+                    11,
+                    81
+                ],
+                [
+                    11,
+                    90
+                ],
+                [
+                    12,
+                    59
+                ],
+                [
+                    13,
+                    17
+                ],
+                [
+                    13,
+                    24
+                ],
+                [
+                    16,
+                    18
+                ],
+                [
+                    16,
+                    75
+                ],
+                [
+                    17,
+                    65
+                ],
+                [
+                    18,
+                    57
+                ],
+                [
+                    19,
+                    23
+                ],
+                [
+                    19,
+                    65
+                ],
+                [
+                    20,
+                    100
+                ],
+                [
+                    21,
+                    41
+                ],
+                [
+                    21,
+                    77
+                ],
+                [
+                    25,
+                    53
+                ],
+                [
+                    25,
+                    96
+                ],
+                [
+                    26,
+                    85
+                ],
+                [
+                    26,
+                    86
+                ],
+                [
+                    27,
+                    41
+                ],
+                [
+                    29,
+                    93
+                ],
+                [
+                    31,
+                    83
+                ],
+                [
+                    35,
+                    55
+                ],
+                [
+                    35,
+                    95
+                ],
+                [
+                    36,
+                    68
+                ],
+                [
+                    36,
+                    70
+                ],
+                [
+                    37,
+                    63
+                ],
+                [
+                    40,
+                    47
+                ],
+                [
+                    40,
+                    48
+                ],
+                [
+                    40,
+                    79
+                ],
+                [
+                    40,
+                    98
+                ],
+                [
+                    40,
+                    99
+                ],
+                [
+                    41,
+                    69
+                ],
+                [
+                    44,
+                    51
+                ],
+                [
+                    44,
+                    78
+                ],
+                [
+                    51,
+                    63
+                ],
+                [
+                    51,
+                    79
+                ],
+                [
+                    52,
+                    52
+                ],
+                [
+                    53,
+                    64
+                ],
+                [
+                    55,
+                    56
+                ],
+                [
+                    57,
+                    62
+                ],
+                [
+                    58,
+                    86
+                ],
+                [
+                    60,
+                    63
+                ],
+                [
+                    60,
+                    91
+                ],
+                [
+                    62,
+                    94
+                ],
+                [
+                    63,
+                    77
+                ],
+                [
+                    64,
+                    92
+                ],
+                [
+                    66,
+                    82
+                ],
+                [
+                    66,
+                    92
+                ],
+                [
+                    66,
+                    97
+                ],
+                [
+                    67,
+                    85
+                ],
+                [
+                    68,
+                    71
+                ],
+                [
+                    70,
+                    74
+                ],
+                [
+                    71,
+                    75
+                ],
+                [
+                    71,
+                    78
+                ],
+                [
+                    71,
+                    98
+                ],
+                [
+                    71,
+                    98
+                ],
+                [
+                    72,
+                    74
+                ],
+                [
+                    77,
+                    83
+                ],
+                [
+                    77,
+                    97
+                ],
+                [
+                    78,
+                    94
+                ],
+                [
+                    79,
+                    79
+                ],
+                [
+                    79,
+                    85
+                ],
+                [
+                    80,
+                    91
+                ],
+                [
+                    83,
+                    100
+                ],
+                [
+                    84,
+                    86
+                ],
+                [
+                    85,
+                    96
+                ],
+                [
+                    88,
+                    90
+                ],
+                [
+                    88,
+                    95
+                ],
+                [
+                    92,
+                    93
+                ],
+                [
+                    94,
+                    94
+                ],
+                [
+                    95,
+                    96
+                ],
+                [
+                    98,
+                    98
+                ],
+                [
+                    98,
+                    100
+                ]
+            ],
+            "output": 99
+        },
+        {
+            "input": [
+                [
+                    1,
+                    2
+                ],
+                [
+                    14,
+                    99
+                ],
+                [
+                    34,
+                    81
+                ],
+                [
+                    51,
+                    52
+                ],
+                [
+                    54,
+                    65
+                ],
+                [
+                    62,
+                    68
+                ],
+                [
+                    66,
+                    94
+                ],
+                [
+                    68,
+                    68
+                ],
+                [
+                    86,
+                    95
+                ]
+            ],
+            "output": 88
+        }
+    ],
+    "haskell_template": "numberOfPoints :: [[Int]] -> Int\nnumberOfPoints nums ",
+    "ocaml_template": "let numberOfPoints (nums: int list list) : int =  ",
+    "scala_template": "def numberOfPoints(nums: List[List[Int]]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int numberOfPoints(List<List<Integer>> nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def numberOfPoints(self, nums):\n        \"\"\"\n        :type nums: List[List[int]]\n        :rtype: int\n        \"\"\"\n        "
+}

points_that_intersect_with_cars/ocaml_tests/main.ml

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

points_that_intersect_with_cars/scala_tests/MySuite.scala

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

power_of_heroes/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(141, sumOfPower(Arrays.asList(2,1,4)));
+}
+@Test
+public void test2() {
+    assertEquals(7, sumOfPower(Arrays.asList(1,1,1)));
+}
+
+}

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

prime_in_diagonal/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(11, diagonalPrime(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,2,3)),new ArrayList<>(Arrays.asList(5,6,7)),new ArrayList<>(Arrays.asList(9,10,11))))));
+}
+@Test
+public void test2() {
+    assertEquals(17, diagonalPrime(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,2,3)),new ArrayList<>(Arrays.asList(5,17,7)),new ArrayList<>(Arrays.asList(9,11,10))))));
+}
+
+}

prime_in_diagonal/ocaml_tests/main.ml

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

prime_in_diagonal/scala_tests/MySuite.scala

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

prime_subtraction_operation/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 (primeSubOperation [4,9,6,10])," True (primeSubOperation [4,9,6,10]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (primeSubOperation [6,8,11,12])," True (primeSubOperation [6,8,11,12]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (primeSubOperation [5,8,3])," False (primeSubOperation [5,8,3]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

prime_subtraction_operation/java_tests/Main.java

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

prime_subtraction_operation/meta.json

@@ -0,0 +1,3144 @@
+{
+    "id": 2716,
+    "name": "prime_subtraction_operation",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/prime-subtraction-operation/",
+    "date": "1679184000000",
+    "task_description": "You are given a **0-indexed** integer array `nums` of length `n`. You can perform the following operation as many times as you want: Pick an index `i` that you haven’t picked before, and pick a prime `p` **strictly less than** `nums[i]`, then subtract `p` from `nums[i]`. Return _true if you can make `nums` a strictly increasing array using the above operation and false otherwise._ A **strictly increasing array** is an array whose each element is strictly greater than its preceding element. **Example 1:** ``` **Input:** nums = [4,9,6,10] **Output:** true **Explanation:** In the first operation: Pick i = 0 and p = 3, and then subtract 3 from nums[0], so that nums becomes [1,9,6,10]. In the second operation: i = 1, p = 7, subtract 7 from nums[1], so nums becomes equal to [1,2,6,10]. After the second operation, nums is sorted in strictly increasing order, so the answer is true. ``` **Example 2:** ``` **Input:** nums = [6,8,11,12] **Output:** true **Explanation: **Initially nums is sorted in strictly increasing order, so we don't need to make any operations. ``` **Example 3:** ``` **Input:** nums = [5,8,3] **Output:** false **Explanation:** It can be proven that there is no way to perform operations to make nums sorted in strictly increasing order, so the answer is false. ``` **Constraints:** `1 <= nums.length <= 1000` `1 <= nums[i] <= 1000` `nums.length == n`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [4,9,6,10]",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [6,8,11,12]",
+            "output": "true "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [5,8,3]",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                10,
+                11,
+                21,
+                27,
+                31,
+                33,
+                37,
+                47,
+                49,
+                61,
+                67,
+                71,
+                79,
+                81,
+                91,
+                99,
+                105,
+                106,
+                107,
+                116,
+                122,
+                123,
+                129,
+                69,
+                659,
+                443,
+                353,
+                739,
+                226,
+                520,
+                871,
+                220,
+                577,
+                802,
+                499,
+                919,
+                238,
+                147,
+                259,
+                754,
+                592,
+                963,
+                487,
+                765,
+                889,
+                606,
+                113,
+                595,
+                967,
+                755,
+                110,
+                155,
+                362,
+                998,
+                669,
+                297,
+                198,
+                933,
+                977,
+                819,
+                9,
+                142,
+                931,
+                377,
+                470,
+                108,
+                278,
+                612,
+                368,
+                66,
+                855,
+                694,
+                618,
+                171,
+                397,
+                265,
+                721,
+                587,
+                367,
+                922,
+                980,
+                171,
+                285,
+                750,
+                170,
+                106,
+                736,
+                389,
+                430,
+                300,
+                347,
+                861,
+                483,
+                174,
+                590,
+                408,
+                196,
+                897,
+                189,
+                952,
+                153,
+                914,
+                240,
+                657,
+                597,
+                209,
+                548,
+                783,
+                414,
+                303,
+                586,
+                49,
+                262,
+                702,
+                76,
+                166,
+                59,
+                581,
+                434,
+                422,
+                709,
+                504,
+                739,
+                543,
+                455,
+                172,
+                998,
+                52,
+                226,
+                398,
+                458,
+                378,
+                171,
+                213,
+                17,
+                496,
+                879,
+                30,
+                208,
+                133,
+                483,
+                97,
+                552,
+                707,
+                513,
+                322,
+                423,
+                287,
+                926,
+                607,
+                82,
+                861,
+                76,
+                512,
+                461,
+                37,
+                364,
+                850,
+                179,
+                106,
+                390,
+                842,
+                685,
+                652,
+                247,
+                781,
+                95,
+                187,
+                570,
+                700,
+                527,
+                700,
+                302,
+                624,
+                503,
+                567,
+                526,
+                508,
+                748,
+                654,
+                185,
+                828,
+                960,
+                556,
+                243,
+                418,
+                221,
+                825,
+                978,
+                506,
+                806,
+                776,
+                457,
+                927,
+                215,
+                509,
+                800,
+                802,
+                248,
+                499,
+                218,
+                189,
+                33,
+                978,
+                28,
+                492,
+                767,
+                892,
+                990,
+                491,
+                103,
+                673,
+                370,
+                215,
+                517,
+                286,
+                777,
+                885,
+                657,
+                107,
+                897,
+                225,
+                736,
+                811,
+                510,
+                609,
+                554,
+                36,
+                992,
+                627,
+                514,
+                926,
+                310,
+                970,
+                598,
+                129,
+                839,
+                732,
+                999,
+                94,
+                243,
+                521,
+                711,
+                279,
+                120,
+                977,
+                925,
+                653,
+                756,
+                750,
+                354,
+                989,
+                989,
+                642,
+                706,
+                273,
+                739,
+                600,
+                298,
+                695,
+                949,
+                143,
+                355,
+                226,
+                961,
+                554,
+                781,
+                826,
+                866,
+                707,
+                95,
+                16,
+                931,
+                899,
+                112,
+                889,
+                843,
+                40,
+                754,
+                182,
+                962,
+                495,
+                48,
+                133,
+                592,
+                856,
+                870,
+                670,
+                338,
+                307,
+                452,
+                139,
+                458,
+                523,
+                860,
+                966,
+                815,
+                963,
+                281,
+                256,
+                411,
+                49,
+                180,
+                671,
+                358,
+                395,
+                18,
+                700,
+                170,
+                476,
+                860,
+                172,
+                112,
+                450,
+                245,
+                714,
+                885,
+                31,
+                609,
+                145,
+                202,
+                236,
+                995,
+                488,
+                196,
+                993,
+                19,
+                890,
+                698,
+                161,
+                461,
+                768,
+                588,
+                812,
+                226,
+                855,
+                408,
+                131,
+                138,
+                991,
+                510,
+                165,
+                972,
+                544,
+                652,
+                658,
+                985,
+                136,
+                668,
+                500,
+                865,
+                409,
+                267,
+                197,
+                314,
+                854,
+                923,
+                221,
+                254,
+                992,
+                614,
+                442,
+                849,
+                573,
+                552,
+                962,
+                550,
+                630,
+                899,
+                879,
+                660,
+                977,
+                960,
+                797,
+                91,
+                91,
+                702,
+                382,
+                801,
+                842,
+                812,
+                393,
+                481,
+                169,
+                919,
+                128,
+                698,
+                119,
+                135,
+                942,
+                535,
+                502,
+                545,
+                588,
+                989,
+                156,
+                246,
+                29,
+                833,
+                884,
+                172,
+                211,
+                843,
+                382,
+                550,
+                761,
+                78,
+                68,
+                251,
+                431,
+                325,
+                574,
+                492,
+                36,
+                210,
+                961,
+                509,
+                86,
+                798,
+                529,
+                150,
+                880,
+                251,
+                381,
+                642,
+                148,
+                439,
+                351,
+                564,
+                333,
+                68,
+                709,
+                747,
+                251,
+                826,
+                439,
+                221,
+                158,
+                217,
+                232,
+                314,
+                386,
+                780,
+                94,
+                572,
+                775,
+                164,
+                912,
+                615,
+                525,
+                594,
+                973,
+                638,
+                109,
+                200,
+                899,
+                679,
+                685,
+                586,
+                782,
+                224,
+                327,
+                311,
+                694,
+                466,
+                267,
+                431,
+                353,
+                759,
+                882,
+                754,
+                635,
+                842,
+                369,
+                458,
+                819,
+                820,
+                314,
+                307,
+                226,
+                964,
+                810,
+                721,
+                61,
+                221,
+                992,
+                272,
+                91,
+                819,
+                245,
+                791,
+                653,
+                608,
+                323,
+                614,
+                971,
+                594,
+                453,
+                221,
+                489,
+                65,
+                768,
+                971,
+                839,
+                828,
+                853,
+                568,
+                401,
+                755,
+                203,
+                795,
+                284,
+                227,
+                422,
+                649,
+                634,
+                447,
+                162,
+                104,
+                982,
+                438,
+                550,
+                626,
+                22,
+                129,
+                87,
+                565,
+                240,
+                266,
+                674,
+                386,
+                945,
+                760,
+                38,
+                470,
+                320,
+                122,
+                670,
+                593,
+                747,
+                562,
+                351,
+                446,
+                487,
+                464,
+                789,
+                315,
+                962,
+                809,
+                680,
+                898,
+                988,
+                870,
+                337,
+                984,
+                551,
+                474,
+                390,
+                228,
+                310,
+                653,
+                823,
+                292,
+                349,
+                863,
+                346,
+                319,
+                833,
+                561,
+                592,
+                45,
+                348,
+                562,
+                599,
+                682,
+                282,
+                775,
+                191,
+                749,
+                741,
+                739,
+                138,
+                244,
+                414,
+                77,
+                206,
+                644,
+                636,
+                456,
+                497,
+                173,
+                475,
+                805,
+                525,
+                433,
+                495,
+                695,
+                629,
+                208,
+                102,
+                203,
+                432,
+                590,
+                933,
+                539,
+                569,
+                591,
+                254,
+                722,
+                896,
+                349,
+                893,
+                127,
+                891,
+                744,
+                937,
+                311,
+                163,
+                612,
+                961,
+                621,
+                430,
+                295,
+                913,
+                625,
+                800,
+                32,
+                432,
+                285,
+                210,
+                141,
+                478,
+                408,
+                206,
+                748,
+                601,
+                543,
+                461,
+                443,
+                428,
+                303,
+                508,
+                806,
+                97,
+                727,
+                452,
+                953,
+                647,
+                500,
+                451,
+                449,
+                849,
+                585,
+                821,
+                301,
+                789,
+                312,
+                294,
+                979,
+                930,
+                240,
+                160,
+                227,
+                563,
+                688,
+                471,
+                810,
+                107,
+                192,
+                941,
+                288,
+                194,
+                905,
+                786,
+                528,
+                487,
+                704,
+                167,
+                261,
+                696,
+                821,
+                779,
+                671,
+                701,
+                601,
+                788,
+                899,
+                270,
+                600,
+                600,
+                137,
+                617,
+                778,
+                733,
+                544,
+                602,
+                632,
+                82,
+                120,
+                625,
+                311,
+                266,
+                106,
+                873,
+                600,
+                763,
+                541,
+                770,
+                247,
+                919,
+                994,
+                431,
+                945,
+                833,
+                421,
+                873,
+                972,
+                301,
+                373,
+                439,
+                671,
+                173,
+                523,
+                378,
+                214,
+                559,
+                162,
+                312,
+                961,
+                876,
+                166,
+                101,
+                272,
+                628,
+                299,
+                676,
+                362,
+                545,
+                307,
+                498,
+                40,
+                218,
+                672,
+                7,
+                166,
+                752,
+                178,
+                91,
+                373,
+                833,
+                884,
+                454,
+                919,
+                802,
+                917,
+                5,
+                814,
+                494,
+                565,
+                141,
+                471,
+                216,
+                394,
+                318,
+                619,
+                975,
+                433,
+                703,
+                784,
+                522,
+                766,
+                953,
+                69,
+                879,
+                396,
+                600,
+                289,
+                811,
+                144,
+                160,
+                33,
+                797,
+                771,
+                343,
+                212,
+                468,
+                958,
+                251,
+                160,
+                547,
+                101,
+                987,
+                488,
+                414,
+                174,
+                627,
+                668,
+                283,
+                93,
+                647,
+                340,
+                655,
+                12,
+                25,
+                902,
+                619,
+                436,
+                286,
+                777,
+                461,
+                709,
+                945,
+                436,
+                52,
+                46,
+                899,
+                548,
+                283,
+                991,
+                336,
+                693,
+                718,
+                146,
+                189,
+                788,
+                19,
+                402,
+                425,
+                21,
+                648,
+                280,
+                618,
+                193,
+                683,
+                898,
+                460,
+                786,
+                943,
+                180,
+                515,
+                184,
+                27,
+                510,
+                225,
+                265,
+                233,
+                148,
+                71,
+                64,
+                931,
+                503,
+                752,
+                926,
+                460,
+                36,
+                123,
+                939,
+                813,
+                150,
+                176,
+                23,
+                934,
+                832,
+                874,
+                457,
+                52,
+                283,
+                569,
+                177,
+                422,
+                558,
+                849,
+                328,
+                647,
+                980,
+                699,
+                659,
+                465,
+                845,
+                326,
+                948,
+                567,
+                976,
+                565,
+                425,
+                629,
+                217,
+                143,
+                256,
+                987,
+                401,
+                283,
+                754,
+                404,
+                265,
+                999,
+                897,
+                904,
+                776,
+                343,
+                368,
+                240,
+                634,
+                23,
+                900,
+                616,
+                987,
+                341,
+                959,
+                512,
+                936,
+                28,
+                115,
+                460,
+                903,
+                839,
+                638,
+                644,
+                544,
+                736,
+                945,
+                970,
+                895,
+                234,
+                721,
+                238,
+                468,
+                282,
+                230,
+                83,
+                232,
+                881,
+                686,
+                633,
+                765,
+                165,
+                996,
+                905,
+                868,
+                579,
+                137,
+                850,
+                431,
+                443,
+                845,
+                646,
+                796,
+                941,
+                526,
+                622,
+                365,
+                718,
+                260,
+                785,
+                534,
+                745,
+                96,
+                384,
+                412,
+                410,
+                613,
+                799,
+                889,
+                575,
+                463,
+                699,
+                929,
+                542,
+                616,
+                487,
+                267,
+                835
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                1,
+                5,
+                7,
+                15,
+                23,
+                26,
+                29,
+                31,
+                32,
+                40,
+                44,
+                50,
+                51,
+                53,
+                59,
+                67,
+                68,
+                73,
+                75,
+                77,
+                83,
+                84,
+                88,
+                108,
+                113,
+                118,
+                120,
+                23,
+                268,
+                211,
+                978,
+                154,
+                25,
+                252,
+                80,
+                793,
+                899,
+                54,
+                282,
+                963,
+                47,
+                733,
+                104,
+                157,
+                123,
+                552,
+                620,
+                361,
+                477,
+                371,
+                534,
+                694,
+                74,
+                702,
+                724,
+                844,
+                820,
+                687,
+                174,
+                118,
+                553,
+                802,
+                442,
+                398,
+                270,
+                657,
+                217,
+                722,
+                510,
+                68,
+                49,
+                700,
+                492,
+                941,
+                482,
+                885,
+                605,
+                885,
+                200,
+                886,
+                961,
+                403,
+                899,
+                235,
+                992,
+                646,
+                546,
+                33,
+                184,
+                828,
+                462,
+                697,
+                185,
+                428,
+                695,
+                221,
+                31,
+                163,
+                287,
+                778,
+                777,
+                817,
+                434,
+                190,
+                487,
+                719,
+                746,
+                699,
+                68,
+                704,
+                626,
+                805,
+                822,
+                791,
+                222,
+                893,
+                894,
+                982,
+                513,
+                759,
+                199,
+                640,
+                287,
+                229,
+                825,
+                945,
+                418,
+                384,
+                497,
+                748,
+                879,
+                579,
+                221,
+                861,
+                441,
+                788,
+                803,
+                746,
+                476,
+                496,
+                406,
+                683,
+                999,
+                854,
+                875,
+                542,
+                308,
+                273,
+                221,
+                705,
+                84,
+                346,
+                831,
+                956,
+                566,
+                999,
+                55,
+                130,
+                472,
+                315,
+                832,
+                100,
+                671,
+                839,
+                605,
+                630,
+                194,
+                63
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                1,
+                3,
+                7,
+                9,
+                14,
+                16
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                8,
+                13,
+                18,
+                21,
+                24,
+                29,
+                31,
+                36,
+                37,
+                41,
+                61,
+                71,
+                72,
+                78,
+                80,
+                84,
+                87,
+                94,
+                100,
+                105,
+                106,
+                108,
+                111,
+                72,
+                193,
+                847,
+                634,
+                793,
+                764,
+                229,
+                809,
+                325,
+                886,
+                333,
+                122,
+                53,
+                248,
+                807,
+                286,
+                323,
+                232,
+                215,
+                741,
+                163,
+                888,
+                69,
+                17,
+                860,
+                744,
+                178,
+                762,
+                291,
+                413,
+                449,
+                904,
+                351,
+                249,
+                898,
+                177,
+                492,
+                332,
+                793,
+                874,
+                561,
+                500,
+                568,
+                753,
+                905,
+                739,
+                672,
+                783,
+                355,
+                935,
+                328,
+                509,
+                127,
+                332,
+                273,
+                498,
+                502,
+                693,
+                733,
+                489,
+                619,
+                278,
+                400,
+                214,
+                390,
+                251,
+                47,
+                317,
+                478,
+                734,
+                998,
+                840,
+                207,
+                24,
+                299,
+                868,
+                158,
+                15,
+                821,
+                373,
+                524,
+                552,
+                345,
+                326,
+                375,
+                632,
+                688,
+                499,
+                981,
+                956,
+                300,
+                232,
+                618,
+                659,
+                495,
+                501,
+                347,
+                285,
+                873,
+                133,
+                563,
+                403,
+                513,
+                469,
+                913,
+                257,
+                886,
+                640,
+                370,
+                610,
+                11,
+                793,
+                716,
+                557,
+                91,
+                1,
+                472,
+                931,
+                874,
+                87,
+                152,
+                538,
+                132,
+                965,
+                200,
+                337,
+                571,
+                430,
+                796,
+                737,
+                33,
+                210,
+                728,
+                543,
+                321,
+                729,
+                545,
+                273,
+                178,
+                881,
+                563,
+                251,
+                534,
+                573,
+                826,
+                880,
+                900,
+                556,
+                799,
+                271,
+                219,
+                172,
+                817,
+                706,
+                197,
+                142,
+                728,
+                116,
+                648,
+                583,
+                886,
+                864,
+                324,
+                622,
+                603,
+                682,
+                129,
+                974,
+                466,
+                13,
+                403,
+                65,
+                666,
+                230,
+                807,
+                965,
+                68,
+                561,
+                278,
+                500,
+                148,
+                957,
+                663,
+                506,
+                323,
+                827,
+                962,
+                590,
+                934,
+                13,
+                723,
+                156,
+                522,
+                944,
+                276,
+                845,
+                267,
+                908,
+                365,
+                323,
+                822,
+                477,
+                240,
+                701,
+                813,
+                163,
+                751,
+                329,
+                444,
+                548,
+                775,
+                349,
+                807,
+                836,
+                959,
+                117,
+                548,
+                381,
+                700,
+                781,
+                44,
+                543,
+                199,
+                661,
+                679,
+                464,
+                195,
+                470,
+                136,
+                194,
+                891,
+                382,
+                989,
+                381,
+                107,
+                764,
+                668,
+                696,
+                269,
+                729,
+                925,
+                581,
+                395,
+                596,
+                801,
+                155,
+                721,
+                154,
+                566,
+                983,
+                33,
+                192,
+                85
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                12,
+                16,
+                22,
+                28,
+                34,
+                36,
+                39,
+                41,
+                45,
+                58,
+                2,
+                209,
+                861,
+                902,
+                768,
+                303,
+                948,
+                347,
+                777,
+                454,
+                243,
+                16,
+                665,
+                511,
+                867,
+                342,
+                181,
+                898,
+                717,
+                778,
+                17,
+                20,
+                199,
+                176,
+                870,
+                63,
+                969,
+                224,
+                267,
+                399,
+                377,
+                643,
+                832,
+                223,
+                488,
+                888,
+                133,
+                200,
+                969,
+                415,
+                892,
+                154,
+                871,
+                34,
+                61,
+                574,
+                810,
+                852,
+                621,
+                524,
+                509,
+                589,
+                562,
+                160,
+                189,
+                827,
+                925,
+                18,
+                131,
+                377,
+                748,
+                285,
+                334,
+                720,
+                848,
+                158,
+                641,
+                867,
+                323,
+                768,
+                684,
+                835,
+                498,
+                989,
+                498,
+                30,
+                346,
+                563,
+                513,
+                125,
+                152,
+                644,
+                124,
+                625,
+                580,
+                554,
+                699,
+                580,
+                870,
+                930,
+                832,
+                930,
+                831,
+                273,
+                23,
+                755,
+                778,
+                308,
+                584,
+                870,
+                149,
+                298,
+                166,
+                981,
+                482,
+                745,
+                312,
+                537,
+                954,
+                435,
+                505,
+                924,
+                495,
+                802,
+                605,
+                985,
+                764,
+                839,
+                328,
+                669,
+                525,
+                717,
+                602,
+                8,
+                517,
+                646,
+                229,
+                657,
+                822,
+                96,
+                366,
+                712,
+                390,
+                947,
+                259,
+                504,
+                252,
+                594,
+                766,
+                979,
+                993,
+                912,
+                626,
+                239,
+                994,
+                982,
+                457,
+                358,
+                380,
+                351,
+                819,
+                403,
+                973,
+                597,
+                784,
+                612,
+                325,
+                760,
+                701,
+                775,
+                350,
+                405,
+                114,
+                971,
+                214,
+                323,
+                440,
+                714,
+                357,
+                385,
+                58,
+                652,
+                443,
+                355,
+                541,
+                157,
+                653,
+                41,
+                390,
+                604,
+                8,
+                253,
+                30,
+                430,
+                613,
+                721,
+                440,
+                752,
+                475,
+                489,
+                428,
+                153,
+                974,
+                787,
+                858,
+                462,
+                837,
+                270,
+                42,
+                76,
+                780,
+                942,
+                116,
+                428,
+                965,
+                46,
+                453,
+                553,
+                672,
+                26,
+                620,
+                205,
+                162,
+                471,
+                641,
+                238,
+                865,
+                941,
+                503,
+                698,
+                38,
+                691,
+                863,
+                495,
+                168,
+                9,
+                399,
+                368,
+                779,
+                167,
+                191,
+                733,
+                966,
+                613,
+                37,
+                953,
+                205,
+                627,
+                859,
+                734,
+                456,
+                927,
+                949,
+                915,
+                546,
+                141,
+                532,
+                707,
+                169,
+                361,
+                304,
+                291,
+                239,
+                106,
+                52,
+                706,
+                522,
+                853,
+                583,
+                467,
+                735,
+                985,
+                801,
+                302,
+                967,
+                345,
+                963,
+                526,
+                422,
+                897,
+                498,
+                661,
+                175,
+                97,
+                554,
+                61,
+                425,
+                766,
+                813,
+                666,
+                127,
+                250,
+                953,
+                339,
+                723,
+                530,
+                818,
+                24,
+                889,
+                323,
+                771,
+                112,
+                398,
+                775,
+                857,
+                262,
+                904,
+                870,
+                725,
+                361,
+                507,
+                868,
+                612,
+                808,
+                411,
+                904,
+                981,
+                601,
+                319,
+                579,
+                521,
+                781,
+                198
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                3,
+                6,
+                9,
+                11,
+                18,
+                20,
+                22,
+                25,
+                32,
+                36,
+                37,
+                44,
+                45,
+                54,
+                57,
+                59,
+                65,
+                75,
+                78,
+                80,
+                81,
+                27,
+                615,
+                402,
+                224,
+                342,
+                222,
+                152,
+                822,
+                860,
+                585,
+                744,
+                869,
+                820,
+                769,
+                621,
+                220,
+                834,
+                801,
+                502,
+                250,
+                353,
+                174,
+                647,
+                672,
+                553,
+                230,
+                608,
+                666,
+                572,
+                638,
+                709,
+                136,
+                488,
+                574,
+                205,
+                711,
+                452,
+                872,
+                372,
+                494,
+                781,
+                616,
+                717,
+                650,
+                650,
+                69,
+                660,
+                864,
+                839,
+                120,
+                468,
+                679,
+                763,
+                210,
+                274,
+                611,
+                356,
+                497,
+                800,
+                763,
+                345,
+                797,
+                148,
+                299,
+                714,
+                426,
+                602,
+                86,
+                617,
+                400,
+                299,
+                192,
+                707,
+                307,
+                487,
+                568,
+                566,
+                476,
+                331,
+                815,
+                228,
+                312,
+                88,
+                49,
+                423,
+                508,
+                430,
+                352,
+                30,
+                801,
+                591,
+                573,
+                742,
+                311,
+                812,
+                178,
+                25,
+                379,
+                172,
+                529,
+                210,
+                171,
+                369,
+                105,
+                501,
+                838,
+                319,
+                62,
+                212,
+                512,
+                667,
+                423,
+                735,
+                944,
+                731,
+                867,
+                624,
+                750,
+                312
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                11,
+                17,
+                22,
+                34,
+                44,
+                51,
+                52,
+                54,
+                60,
+                65,
+                73,
+                81,
+                84,
+                90,
+                85,
+                744,
+                616,
+                482,
+                1,
+                509,
+                784,
+                532,
+                436,
+                109,
+                733,
+                996,
+                199,
+                28,
+                748,
+                840,
+                455,
+                738,
+                71,
+                340,
+                320,
+                712,
+                301,
+                97,
+                550,
+                580,
+                729,
+                9,
+                979,
+                898,
+                954,
+                508,
+                735,
+                143,
+                422,
+                63,
+                502,
+                635,
+                426,
+                68,
+                325,
+                941,
+                848,
+                713,
+                634,
+                345,
+                65,
+                397,
+                684,
+                855,
+                400,
+                477,
+                280,
+                704,
+                272,
+                125,
+                974,
+                211,
+                940,
+                316,
+                572,
+                42,
+                887,
+                446,
+                995,
+                788,
+                209,
+                57,
+                837,
+                444,
+                632,
+                423,
+                744,
+                771,
+                840,
+                652,
+                192,
+                17,
+                307,
+                884,
+                490,
+                225,
+                722,
+                598,
+                9,
+                681,
+                371,
+                285,
+                319,
+                961,
+                296,
+                742,
+                994,
+                202,
+                841,
+                113,
+                190,
+                457,
+                915,
+                979,
+                9,
+                995,
+                218,
+                265,
+                908,
+                116,
+                370,
+                946,
+                728,
+                263,
+                167,
+                706,
+                490,
+                786,
+                673,
+                25,
+                963,
+                379,
+                447,
+                571,
+                343,
+                853,
+                389,
+                877,
+                348,
+                595,
+                66,
+                187,
+                82,
+                731,
+                520,
+                21,
+                894,
+                413,
+                196,
+                711,
+                122,
+                958,
+                300,
+                254,
+                947,
+                100,
+                590,
+                228,
+                147,
+                907,
+                525,
+                146,
+                907,
+                527,
+                572,
+                884,
+                827,
+                17,
+                737,
+                478,
+                122,
+                963,
+                405,
+                880,
+                467,
+                373,
+                96,
+                853,
+                93,
+                476,
+                178,
+                82,
+                686,
+                863,
+                81,
+                793,
+                21,
+                703,
+                553,
+                418,
+                684,
+                423,
+                394,
+                876,
+                204,
+                822,
+                778,
+                726,
+                52,
+                827,
+                815,
+                3,
+                164,
+                397,
+                259,
+                203,
+                947,
+                44,
+                888,
+                52,
+                19,
+                793,
+                805,
+                242,
+                854,
+                516,
+                540,
+                612,
+                11,
+                672,
+                770,
+                412,
+                61,
+                813,
+                397,
+                46,
+                808,
+                67,
+                892,
+                434,
+                309,
+                683,
+                165,
+                527,
+                467,
+                132,
+                199,
+                712,
+                528,
+                19,
+                900,
+                613,
+                200,
+                927,
+                294,
+                189,
+                310,
+                255,
+                469,
+                172,
+                599,
+                696,
+                148,
+                700,
+                150,
+                712,
+                584,
+                411,
+                863,
+                370,
+                458,
+                637,
+                940,
+                694,
+                232,
+                547,
+                442,
+                41,
+                1,
+                113,
+                953,
+                304,
+                199,
+                499,
+                795,
+                849,
+                825,
+                976,
+                141,
+                984,
+                917,
+                863,
+                441,
+                946,
+                216,
+                351,
+                332,
+                734,
+                209,
+                620,
+                568,
+                505,
+                625,
+                948,
+                932,
+                838,
+                276,
+                833,
+                951,
+                672,
+                926,
+                610,
+                333,
+                349,
+                870,
+                188,
+                951,
+                923,
+                678,
+                5,
+                678,
+                933,
+                148,
+                842,
+                879,
+                257,
+                242,
+                954,
+                826,
+                365,
+                197,
+                387,
+                555,
+                454,
+                718,
+                899,
+                470,
+                565,
+                922,
+                800,
+                517,
+                443,
+                824,
+                169,
+                673,
+                312,
+                459,
+                553,
+                150,
+                500,
+                208,
+                377,
+                182,
+                793,
+                968,
+                906,
+                974,
+                412,
+                860,
+                297,
+                442,
+                167,
+                81,
+                64,
+                460,
+                775,
+                330,
+                229,
+                248,
+                37,
+                326,
+                419,
+                168,
+                251,
+                166,
+                525,
+                855,
+                409,
+                975,
+                311,
+                659,
+                551,
+                647,
+                446,
+                870,
+                691,
+                399,
+                830,
+                411,
+                912,
+                888,
+                952,
+                763,
+                547,
+                866,
+                402,
+                172,
+                651,
+                771,
+                131,
+                226,
+                631,
+                572,
+                951,
+                497,
+                998,
+                570,
+                133,
+                443,
+                237,
+                799,
+                29,
+                401,
+                961,
+                817,
+                143,
+                388,
+                501,
+                101,
+                74,
+                183,
+                787,
+                646,
+                441,
+                860,
+                452,
+                968,
+                83,
+                939,
+                833,
+                413,
+                953,
+                903,
+                494,
+                246,
+                259,
+                175,
+                632,
+                705,
+                356,
+                881,
+                74,
+                976,
+                123,
+                475,
+                931,
+                521,
+                703,
+                190,
+                623,
+                303,
+                188,
+                996,
+                169,
+                590,
+                716,
+                957,
+                421,
+                590,
+                770,
+                803,
+                323,
+                737,
+                108,
+                772,
+                454,
+                283,
+                77,
+                472,
+                825,
+                570,
+                819,
+                762,
+                893,
+                669,
+                533,
+                487,
+                749,
+                562,
+                66,
+                481,
+                389,
+                625,
+                491,
+                680,
+                873,
+                551,
+                362,
+                96,
+                960,
+                259,
+                225,
+                830,
+                334,
+                250,
+                529,
+                148,
+                115,
+                251,
+                411,
+                132,
+                261,
+                54,
+                449,
+                874,
+                974,
+                187,
+                488,
+                663,
+                326,
+                359,
+                106,
+                677,
+                271,
+                256,
+                924,
+                923,
+                967,
+                782,
+                324,
+                24,
+                974,
+                301,
+                384,
+                339,
+                552,
+                276,
+                827,
+                928,
+                149,
+                710,
+                699,
+                399,
+                680,
+                789,
+                787,
+                948,
+                224,
+                691,
+                370,
+                705,
+                804,
+                671,
+                618,
+                627,
+                875,
+                381,
+                678,
+                808,
+                587,
+                468,
+                436,
+                488,
+                505,
+                216,
+                275,
+                927,
+                385,
+                755,
+                988,
+                227,
+                484,
+                898,
+                450,
+                251,
+                461,
+                164,
+                435,
+                549,
+                504,
+                219,
+                740,
+                152,
+                117,
+                740,
+                462,
+                846,
+                242,
+                812,
+                729,
+                925,
+                669,
+                244,
+                421,
+                12,
+                387,
+                54,
+                829,
+                81,
+                2,
+                297,
+                876,
+                103,
+                752,
+                372,
+                468,
+                67,
+                600,
+                553,
+                923,
+                307,
+                337,
+                889,
+                601,
+                244,
+                49,
+                41,
+                915,
+                286,
+                314,
+                666,
+                520,
+                560,
+                746,
+                463,
+                728,
+                437,
+                428,
+                99,
+                481,
+                612,
+                667,
+                200,
+                379,
+                480,
+                615,
+                145,
+                182,
+                14,
+                281,
+                526,
+                283,
+                737,
+                754,
+                739,
+                252,
+                144,
+                748,
+                561,
+                155,
+                927,
+                850,
+                157,
+                688,
+                237,
+                854,
+                719,
+                847,
+                295,
+                594,
+                406,
+                967,
+                556,
+                861,
+                778,
+                841,
+                305,
+                357,
+                592,
+                979,
+                775,
+                370,
+                568,
+                338,
+                596,
+                696,
+                885,
+                346,
+                12,
+                814,
+                204,
+                15,
+                89,
+                34,
+                463,
+                346,
+                643,
+                140,
+                588,
+                395,
+                408,
+                510,
+                603,
+                886,
+                841,
+                725,
+                657,
+                124,
+                38,
+                844,
+                943,
+                161,
+                767,
+                564,
+                82,
+                340,
+                408,
+                711,
+                137,
+                654,
+                479,
+                214,
+                41,
+                94,
+                671,
+                455,
+                738,
+                704,
+                871,
+                563,
+                403,
+                522,
+                757,
+                328,
+                1000,
+                520,
+                651,
+                535,
+                170,
+                216,
+                251,
+                796,
+                17,
+                501,
+                534,
+                832,
+                221,
+                469,
+                590,
+                78,
+                479,
+                653,
+                606,
+                248,
+                138,
+                7,
+                983,
+                686,
+                173,
+                223,
+                339,
+                806,
+                250,
+                192,
+                189,
+                974,
+                80,
+                901,
+                561,
+                814,
+                251,
+                428,
+                583,
+                624,
+                812,
+                187,
+                533,
+                853,
+                758,
+                553,
+                498,
+                319,
+                835,
+                819,
+                692,
+                198,
+                314,
+                603,
+                452,
+                953,
+                436,
+                680,
+                648,
+                241,
+                53,
+                541,
+                225,
+                742,
+                803,
+                700,
+                676,
+                700,
+                972,
+                334,
+                622,
+                803,
+                334,
+                501,
+                427,
+                12,
+                849,
+                191,
+                397,
+                672,
+                520,
+                140,
+                55,
+                893,
+                256,
+                45,
+                449,
+                781,
+                288,
+                836,
+                683,
+                318,
+                914,
+                204,
+                683,
+                770,
+                999,
+                393,
+                219,
+                212,
+                592,
+                934,
+                299,
+                915,
+                310,
+                246,
+                514,
+                404,
+                594,
+                336,
+                102,
+                650,
+                298,
+                973,
+                60,
+                886,
+                378,
+                84,
+                468,
+                762,
+                384,
+                813,
+                426,
+                994,
+                966,
+                156,
+                894,
+                339,
+                421,
+                33,
+                942,
+                790,
+                596,
+                999,
+                815,
+                245,
+                336,
+                645,
+                585,
+                939,
+                170,
+                922,
+                757,
+                393,
+                169,
+                252,
+                23,
+                534,
+                808,
+                230,
+                981,
+                777,
+                222,
+                719,
+                570,
+                742,
+                741,
+                946,
+                935,
+                504,
+                851,
+                873,
+                725,
+                679,
+                469,
+                285,
+                893,
+                763,
+                943,
+                538,
+                942,
+                613,
+                839,
+                455,
+                601,
+                644,
+                302,
+                125,
+                899,
+                281,
+                342,
+                576,
+                997,
+                69,
+                677,
+                301,
+                735,
+                718,
+                664,
+                891,
+                96,
+                864,
+                783,
+                734,
+                165,
+                635,
+                109,
+                304,
+                139,
+                637,
+                12,
+                37,
+                465,
+                307,
+                564,
+                221,
+                131,
+                783,
+                979,
+                428,
+                84,
+                723,
+                995,
+                743,
+                66,
+                748,
+                176,
+                820,
+                23,
+                852,
+                931,
+                384,
+                465,
+                634,
+                675,
+                873,
+                821,
+                356,
+                978,
+                503,
+                943,
+                72,
+                771,
+                996,
+                10,
+                400,
+                383,
+                21,
+                918,
+                122,
+                119,
+                194,
+                858,
+                735,
+                345,
+                515,
+                58
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                2,
+                12,
+                17,
+                25,
+                26,
+                28,
+                29,
+                37,
+                39,
+                40,
+                42,
+                45,
+                48,
+                51,
+                59,
+                69,
+                74,
+                83,
+                86,
+                90,
+                93,
+                95,
+                96,
+                98,
+                99,
+                104,
+                109,
+                110,
+                97,
+                998,
+                308,
+                323,
+                474,
+                412,
+                636,
+                567,
+                630,
+                432,
+                459,
+                350,
+                753,
+                121,
+                545,
+                730,
+                597,
+                121,
+                32,
+                98,
+                291,
+                303,
+                418,
+                782,
+                600,
+                813,
+                168,
+                330,
+                720,
+                250,
+                205,
+                490,
+                125,
+                869,
+                893,
+                710,
+                445,
+                530,
+                10,
+                267,
+                719,
+                295,
+                597,
+                560,
+                617,
+                750,
+                514,
+                311,
+                14,
+                853,
+                343,
+                421,
+                501,
+                441,
+                383,
+                32,
+                200,
+                935,
+                495,
+                976,
+                62,
+                863,
+                715,
+                603,
+                338,
+                683,
+                950,
+                994,
+                774,
+                995,
+                840,
+                736,
+                870,
+                680,
+                332,
+                43,
+                882
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                5,
+                9,
+                12,
+                21,
+                26,
+                32,
+                34,
+                35,
+                38,
+                39,
+                46,
+                48,
+                50,
+                51,
+                56,
+                57,
+                70,
+                72,
+                78,
+                84,
+                86,
+                93,
+                94,
+                102,
+                108,
+                109,
+                118,
+                121,
+                118,
+                744,
+                117,
+                982,
+                64,
+                824,
+                534,
+                251,
+                470,
+                995,
+                264,
+                621,
+                867,
+                734,
+                486,
+                914,
+                177,
+                766,
+                572,
+                264,
+                374,
+                310,
+                59,
+                382,
+                853,
+                869,
+                215
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                5,
+                11,
+                16,
+                20,
+                25,
+                27,
+                32,
+                35,
+                38,
+                41,
+                45,
+                57,
+                64,
+                66,
+                76,
+                78,
+                82,
+                88,
+                89,
+                91,
+                99,
+                104,
+                107,
+                109,
+                111,
+                116,
+                122,
+                123,
+                124,
+                122,
+                753,
+                485,
+                747,
+                637,
+                790,
+                655,
+                292,
+                734,
+                981,
+                387,
+                224,
+                80,
+                477,
+                703,
+                907,
+                687,
+                467,
+                246,
+                170,
+                757,
+                909,
+                526,
+                771,
+                708,
+                29,
+                342,
+                778,
+                191,
+                43,
+                68,
+                599,
+                248,
+                341,
+                317,
+                345,
+                559
+            ],
+            "output": false
+        }
+    ],
+    "haskell_template": "primeSubOperation :: [Int] -> Bool\nprimeSubOperation nums ",
+    "ocaml_template": "let primeSubOperation (nums: int list) : bool =  ",
+    "scala_template": "def primeSubOperation(nums: List[Int]): Boolean = { \n    \n}",
+    "java_template": "public static boolean primeSubOperation(List<Integer> nums) {\n\n}",
+    "python_template": "class Solution(object):\n    def primeSubOperation(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: bool\n        \"\"\"\n        "
+}

prime_subtraction_operation/ocaml_tests/main.ml

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

prime_subtraction_operation/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.primeSubOperation(List(4,9,6,10)), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.primeSubOperation(List(6,8,11,12)), true)
+  }
+
+  test("test3") {
+    assertEquals(Main.primeSubOperation(List(5,8,3)), false)
+  }
+
+}