89faea376bbae1bbc08075e7ee258df9dca329683f3b7ec070d414da7b5e4867

.gitattributes

@@ -145,3 +145,9 @@ largest_element_in_an_array_after_merge_operations/meta.json filter=lfs diff=lfs
 length_of_longest_subarray_with_at_most_k_frequency/meta.json filter=lfs diff=lfs merge=lfs -text
 length_of_the_longest_increasing_path/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
 length_of_the_longest_increasing_path/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_non_decreasing_subarray_from_two_arrays/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+longest_non_decreasing_subarray_from_two_arrays/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_palindrome_by_concatenating_two_letter_words/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_path_with_different_adjacent_characters/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_special_path/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_special_path_ii/meta.json filter=lfs diff=lfs merge=lfs -text

longest_increasing_subsequence_ii/ocaml_tests/main.ml

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

longest_increasing_subsequence_ii/scala_tests/MySuite.scala

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

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

longest_nice_subarray/java_tests/Main.java

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

longest_nice_subarray/ocaml_tests/main.ml

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

longest_nice_subarray/scala_tests/MySuite.scala

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

longest_non_decreasing_subarray_from_two_arrays/haskell_tests/Main.hs

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

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

longest_non_decreasing_subarray_from_two_arrays/meta.json

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

longest_palindrome_by_concatenating_two_letter_words/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 (longestPalindrome [ \"lc \", \"cl \", \"gg \"])," 6 (longestPalindrome ["lc","cl","gg"]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (longestPalindrome [ \"ab \", \"ty \", \"yt \", \"lc \", \"cl \", \"ab \"])," 8 (longestPalindrome ["ab","ty","yt","lc","cl","ab"]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (longestPalindrome [ \"cc \", \"ll \", \"xx \"])," 2 (longestPalindrome ["cc","ll","xx"]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

longest_palindrome_by_concatenating_two_letter_words/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(6, longestPalindrome(new ArrayList<>(Arrays.asList("lc","cl","gg"))));
+}
+@Test
+public void test2() {
+    assertEquals(8, longestPalindrome(new ArrayList<>(Arrays.asList("ab","ty","yt","lc","cl","ab"))));
+}
+@Test
+public void test3() {
+    assertEquals(2, longestPalindrome(new ArrayList<>(Arrays.asList("cc","ll","xx"))));
+}
+
+}

longest_palindrome_by_concatenating_two_letter_words/meta.json

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

longest_palindrome_by_concatenating_two_letter_words/ocaml_tests/main.ml

@@ -0,0 +1,29 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 6 (longestPalindrome ["lc";"cl";"gg"])
+
+let test2 _ = assert_equal 8 (longestPalindrome ["ab";"ty";"yt";"lc";"cl";"ab"])
+
+let test3 _ = assert_equal 2 (longestPalindrome ["cc";"ll";"xx"])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for longestPalindrome" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

longest_palindrome_by_concatenating_two_letter_words/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.longestPalindrome(List("lc","cl","gg")), 6)
+  }
+
+  test("test2") {
+    assertEquals(Main.longestPalindrome(List("ab","ty","yt","lc","cl","ab")), 8)
+  }
+
+  test("test3") {
+    assertEquals(Main.longestPalindrome(List("cc","ll","xx")), 2)
+  }
+
+}

longest_palindromic_subsequence_after_at_most_k_operations/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 (longestPalindromicSubsequence \"abced \" 2)," 3 (longestPalindromicSubsequence "abced" 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (longestPalindromicSubsequence \" aaazzz  \" 4)," 6 (longestPalindromicSubsequence " aaazzz " 4))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (longestPalindromicSubsequence  \"bgngurzzgzmenzpemgldtnkwtengymnfuwguviil \" 4)," 19 (longestPalindromicSubsequence "bgngurzzgzmenzpemgldtnkwtengymnfuwguviil" 4))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (longestPalindromicSubsequence  \"mxfldfmfceqnmdnxtyzxpxacyetdefktaulnwmwwinilyosxhjnhfymrcuteiytwowvzafsrzbyeeohikxjzpeshqvbyzfwrtddbsmuvmdkaojytuvmubtkmsrptizalwocnyyxtfjhskamenbulemyblguusw \" 10)," 67 (longestPalindromicSubsequence "mxfldfmfceqnmdnxtyzxpxacyetdefktaulnwmwwinilyosxhjnhfymrcuteiytwowvzafsrzbyeeohikxjzpeshqvbyzfwrtddbsmuvmdkaojytuvmubtkmsrptizalwocnyyxtfjhskamenbulemyblguusw" 10))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (longestPalindromicSubsequence  \"rvxljjsrupvrskplidkerrpabdpfilnpjobtpaydksagivihssbswrmuodpjwitvbmkbcousxzvbzywpqtjhr \" 84)," 67 (longestPalindromicSubsequence "rvxljjsrupvrskplidkerrpabdpfilnpjobtpaydksagivihssbswrmuodpjwitvbmkbcousxzvbzywpqtjhr" 84))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (longestPalindromicSubsequence  \"mwmtldzgbmapsnkjafwnrotwuimbfkbzyenglpqnahlacsstnwoxnkgwqvkbkfdftqoentbbykvikokqhtidlflsqwjuleeuqwnhfgdibfjyfcbvmvwuqsfvttocsrcypg \" 115)," 101 (longestPalindromicSubsequence "mwmtldzgbmapsnkjafwnrotwuimbfkbzyenglpqnahlacsstnwoxnkgwqvkbkfdftqoentbbykvikokqhtidlflsqwjuleeuqwnhfgdibfjyfcbvmvwuqsfvttocsrcypg" 115))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (longestPalindromicSubsequence  \"mgaevjqdbrbbgvrirlznfxncdkgbnhjkqpkusyxwsprerypomqbvhiyxtxvoukpgsfxszjjeqebntfsvdhipvfczwdbcsgujgspvuglgrrpqrzenayndiijjzomdbpcktcfmypsndhcndoltmalwvifypuqqyci \" 89)," 111 (longestPalindromicSubsequence "mgaevjqdbrbbgvrirlznfxncdkgbnhjkqpkusyxwsprerypomqbvhiyxtxvoukpgsfxszjjeqebntfsvdhipvfczwdbcsgujgspvuglgrrpqrzenayndiijjzomdbpcktcfmypsndhcndoltmalwvifypuqqyci" 89))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (longestPalindromicSubsequence  \"bbdbxwmzswununfmmnjddrpddgldjztxzgnmmhnnyqyqmefguektdnsmzyyrbweqbsmyjumvr \" 141)," 67 (longestPalindromicSubsequence "bbdbxwmzswununfmmnjddrpddgldjztxzgnmmhnnyqyqmefguektdnsmzyyrbweqbsmyjumvr" 141))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (longestPalindromicSubsequence  \"mjtqkwvoaqnrbcaxmfltxgxklslfgljvclzkixescuhylueemymirpinpzstcsjogrquxwqxvqzbcvysjhxaigzcxlsgjtujicjjowfprubrfjiewbmhg \" 3)," 44 (longestPalindromicSubsequence "mjtqkwvoaqnrbcaxmfltxgxklslfgljvclzkixescuhylueemymirpinpzstcsjogrquxwqxvqzbcvysjhxaigzcxlsgjtujicjjowfprubrfjiewbmhg" 3))
+
+
+-- 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

longest_palindromic_subsequence_after_at_most_k_operations/java_tests/Main.java

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

longest_palindromic_subsequence_after_at_most_k_operations/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3786,
+    "name": "longest_palindromic_subsequence_after_at_most_k_operations",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/longest-palindromic-subsequence-after-at-most-k-operations/",
+    "date": "2025-02-23 00:00:00",
+    "task_description": "You are given a string `s` and an integer `k`. In one operation, you can replace the character at any position with the next or previous letter in the alphabet (wrapping around so that `'a'` is after `'z'`). For example, replacing `'a'` with the next letter results in `'b'`, and replacing `'a'` with the previous letter results in `'z'`. Similarly, replacing `'z'` with the next letter results in `'a'`, and replacing `'z'` with the previous letter results in `'y'`. Return the length of the **longest palindromic subsequence** of `s` that can be obtained after performing **at most** `k` operations. **Example 1:** **Input:** s = \"abced\", k = 2 **Output:** 3 **Explanation:** Replace `s[1]` with the next letter, and `s` becomes `\"acced\"`. Replace `s[4]` with the previous letter, and `s` becomes `\"accec\"`. The subsequence `\"ccc\"` forms a palindrome of length 3, which is the maximum. **Example 2:** **Input:** s = \"aaazzz\", k = 4 **Output:** 6 **Explanation:** Replace `s[0]` with the previous letter, and `s` becomes `\"zaazzz\"`. Replace `s[4]` with the next letter, and `s` becomes `\"zaazaz\"`. Replace `s[3]` with the next letter, and `s` becomes `\"zaaaaz\"`. The entire string forms a palindrome of length 6. **Constraints:** `1 <= s.length <= 200` `1 <= k <= 200` `s` consists of only lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"abced\", k = 2",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \" aaazzz \", k = 4",
+            "output": "6 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"bgngurzzgzmenzpemgldtnkwtengymnfuwguviil\"",
+                4
+            ],
+            "output": 19
+        },
+        {
+            "input": [
+                "\"mxfldfmfceqnmdnxtyzxpxacyetdefktaulnwmwwinilyosxhjnhfymrcuteiytwowvzafsrzbyeeohikxjzpeshqvbyzfwrtddbsmuvmdkaojytuvmubtkmsrptizalwocnyyxtfjhskamenbulemyblguusw\"",
+                10
+            ],
+            "output": 67
+        },
+        {
+            "input": [
+                "\"rvxljjsrupvrskplidkerrpabdpfilnpjobtpaydksagivihssbswrmuodpjwitvbmkbcousxzvbzywpqtjhr\"",
+                84
+            ],
+            "output": 67
+        },
+        {
+            "input": [
+                "\"mwmtldzgbmapsnkjafwnrotwuimbfkbzyenglpqnahlacsstnwoxnkgwqvkbkfdftqoentbbykvikokqhtidlflsqwjuleeuqwnhfgdibfjyfcbvmvwuqsfvttocsrcypg\"",
+                115
+            ],
+            "output": 101
+        },
+        {
+            "input": [
+                "\"mgaevjqdbrbbgvrirlznfxncdkgbnhjkqpkusyxwsprerypomqbvhiyxtxvoukpgsfxszjjeqebntfsvdhipvfczwdbcsgujgspvuglgrrpqrzenayndiijjzomdbpcktcfmypsndhcndoltmalwvifypuqqyci\"",
+                89
+            ],
+            "output": 111
+        },
+        {
+            "input": [
+                "\"bbdbxwmzswununfmmnjddrpddgldjztxzgnmmhnnyqyqmefguektdnsmzyyrbweqbsmyjumvr\"",
+                141
+            ],
+            "output": 67
+        },
+        {
+            "input": [
+                "\"mjtqkwvoaqnrbcaxmfltxgxklslfgljvclzkixescuhylueemymirpinpzstcsjogrquxwqxvqzbcvysjhxaigzcxlsgjtujicjjowfprubrfjiewbmhg\"",
+                3
+            ],
+            "output": 44
+        },
+        {
+            "input": [
+                "\"bsyoxkfxelibwfjpwybtdmtlgfxdpnmbjggdysqxccacehdvilwacdtvpfokojyezqod\"",
+                197
+            ],
+            "output": 67
+        },
+        {
+            "input": [
+                "qvjpxvmggdghbtwtdfkrvfeiydhphqmghfzyoazoepytwwdiedzpzva",
+                7
+            ],
+            "output": 26
+        },
+        {
+            "input": [
+                "lzxmrntypqvntucnojvfmjqsoygxozzusrokjjlngbaivkyxznjiojqmcbisazkfnzrsegsavlnwfwaok",
+                110
+            ],
+            "output": 70
+        }
+    ],
+    "haskell_template": "longestPalindromicSubsequence :: String -> Int -> Int\nlongestPalindromicSubsequence s k ",
+    "ocaml_template": "let longestPalindromicSubsequence (s: string) (k: int) : int =  ",
+    "scala_template": "def longestPalindromicSubsequence(s: String,k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int longestPalindromicSubsequence(String s, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def longestPalindromicSubsequence(self, s, k):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

longest_palindromic_subsequence_after_at_most_k_operations/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (longestPalindromicSubsequence "abced" 2)
+
+let test2 _ = assert_equal 6 (longestPalindromicSubsequence " aaazzz " 4)
+
+let test3 _ = assert_equal 19 (longestPalindromicSubsequence "bgngurzzgzmenzpemgldtnkwtengymnfuwguviil" 4)
+
+let test4 _ = assert_equal 67 (longestPalindromicSubsequence "mxfldfmfceqnmdnxtyzxpxacyetdefktaulnwmwwinilyosxhjnhfymrcuteiytwowvzafsrzbyeeohikxjzpeshqvbyzfwrtddbsmuvmdkaojytuvmubtkmsrptizalwocnyyxtfjhskamenbulemyblguusw" 10)
+
+let test5 _ = assert_equal 67 (longestPalindromicSubsequence "rvxljjsrupvrskplidkerrpabdpfilnpjobtpaydksagivihssbswrmuodpjwitvbmkbcousxzvbzywpqtjhr" 84)
+
+let test6 _ = assert_equal 101 (longestPalindromicSubsequence "mwmtldzgbmapsnkjafwnrotwuimbfkbzyenglpqnahlacsstnwoxnkgwqvkbkfdftqoentbbykvikokqhtidlflsqwjuleeuqwnhfgdibfjyfcbvmvwuqsfvttocsrcypg" 115)
+
+let test7 _ = assert_equal 111 (longestPalindromicSubsequence "mgaevjqdbrbbgvrirlznfxncdkgbnhjkqpkusyxwsprerypomqbvhiyxtxvoukpgsfxszjjeqebntfsvdhipvfczwdbcsgujgspvuglgrrpqrzenayndiijjzomdbpcktcfmypsndhcndoltmalwvifypuqqyci" 89)
+
+let test8 _ = assert_equal 67 (longestPalindromicSubsequence "bbdbxwmzswununfmmnjddrpddgldjztxzgnmmhnnyqyqmefguektdnsmzyyrbweqbsmyjumvr" 141)
+
+let test9 _ = assert_equal 44 (longestPalindromicSubsequence "mjtqkwvoaqnrbcaxmfltxgxklslfgljvclzkixescuhylueemymirpinpzstcsjogrquxwqxvqzbcvysjhxaigzcxlsgjtujicjjowfprubrfjiewbmhg" 3)
+
+let test10 _ = assert_equal 67 (longestPalindromicSubsequence "bsyoxkfxelibwfjpwybtdmtlgfxdpnmbjggdysqxccacehdvilwacdtvpfokojyezqod" 197)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for longestPalindromicSubsequence" >::: [
+        
+  "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

longest_palindromic_subsequence_after_at_most_k_operations/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.longestPalindromicSubsequence("abced",2), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.longestPalindromicSubsequence(4), 6)
+  }
+
+  test("test3") {
+    assertEquals(Main.longestPalindromicSubsequence("bgngurzzgzmenzpemgldtnkwtengymnfuwguviil",4), 19)
+  }
+
+  test("test4") {
+    assertEquals(Main.longestPalindromicSubsequence("mxfldfmfceqnmdnxtyzxpxacyetdefktaulnwmwwinilyosxhjnhfymrcuteiytwowvzafsrzbyeeohikxjzpeshqvbyzfwrtddbsmuvmdkaojytuvmubtkmsrptizalwocnyyxtfjhskamenbulemyblguusw",10), 67)
+  }
+
+  test("test5") {
+    assertEquals(Main.longestPalindromicSubsequence("rvxljjsrupvrskplidkerrpabdpfilnpjobtpaydksagivihssbswrmuodpjwitvbmkbcousxzvbzywpqtjhr",84), 67)
+  }
+
+  test("test6") {
+    assertEquals(Main.longestPalindromicSubsequence("mwmtldzgbmapsnkjafwnrotwuimbfkbzyenglpqnahlacsstnwoxnkgwqvkbkfdftqoentbbykvikokqhtidlflsqwjuleeuqwnhfgdibfjyfcbvmvwuqsfvttocsrcypg",115), 101)
+  }
+
+  test("test7") {
+    assertEquals(Main.longestPalindromicSubsequence("mgaevjqdbrbbgvrirlznfxncdkgbnhjkqpkusyxwsprerypomqbvhiyxtxvoukpgsfxszjjeqebntfsvdhipvfczwdbcsgujgspvuglgrrpqrzenayndiijjzomdbpcktcfmypsndhcndoltmalwvifypuqqyci",89), 111)
+  }
+
+  test("test8") {
+    assertEquals(Main.longestPalindromicSubsequence("bbdbxwmzswununfmmnjddrpddgldjztxzgnmmhnnyqyqmefguektdnsmzyyrbweqbsmyjumvr",141), 67)
+  }
+
+  test("test9") {
+    assertEquals(Main.longestPalindromicSubsequence("mjtqkwvoaqnrbcaxmfltxgxklslfgljvclzkixescuhylueemymirpinpzstcsjogrquxwqxvqzbcvysjhxaigzcxlsgjtujicjjowfprubrfjiewbmhg",3), 44)
+  }
+
+  test("test10") {
+    assertEquals(Main.longestPalindromicSubsequence("bsyoxkfxelibwfjpwybtdmtlgfxdpnmbjggdysqxccacehdvilwacdtvpfokojyezqod",197), 67)
+  }
+
+}

longest_path_with_different_adjacent_characters/java_tests/Main.java

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

longest_path_with_different_adjacent_characters/meta.json

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

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

longest_special_path/meta.json

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

longest_special_path_ii/java_tests/Main.java

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

longest_special_path_ii/meta.json

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

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

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

longest_square_streak_in_an_array/ocaml_tests/main.ml

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

longest_square_streak_in_an_array/scala_tests/MySuite.scala

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

longest_strictly_increasing_or_strictly_decreasing_subarray/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+longestMonotonicSubarray :: [Int] -> Int
+longestMonotonicSubarray nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (longestMonotonicSubarray [1,4,3,3,2])," 2 (longestMonotonicSubarray [1,4,3,3,2]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (longestMonotonicSubarray [3,3,3,3])," 1 (longestMonotonicSubarray [3,3,3,3]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (longestMonotonicSubarray [3,2,1])," 3 (longestMonotonicSubarray [3,2,1]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (longestMonotonicSubarray [17, 11, 42, 20, 14, 23, 15, 4, 3, 27, 18, 12, 47, 36, 39, 36, 7, 4, 18, 15, 32, 7, 7, 19, 5, 31, 16, 37, 15, 19, 26, 17, 19, 42, 47, 47, 33])," 4 (longestMonotonicSubarray [17, 11, 42, 20, 14, 23, 15, 4, 3, 27, 18, 12, 47, 36, 39, 36, 7, 4, 18, 15, 32, 7, 7, 19, 5, 31, 16, 37, 15, 19, 26, 17, 19, 42, 47, 47, 33]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (longestMonotonicSubarray [4, 41, 47, 46, 12, 46, 22, 9, 27, 11, 41, 47, 7, 21, 6, 35, 48, 47, 39, 30, 12, 50, 36, 16, 36, 23, 3, 34, 21, 4, 48, 11, 22, 13, 27, 40, 47, 46, 20, 3, 4, 46, 13, 50, 8, 6])," 5 (longestMonotonicSubarray [4, 41, 47, 46, 12, 46, 22, 9, 27, 11, 41, 47, 7, 21, 6, 35, 48, 47, 39, 30, 12, 50, 36, 16, 36, 23, 3, 34, 21, 4, 48, 11, 22, 13, 27, 40, 47, 46, 20, 3, 4, 46, 13, 50, 8, 6]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (longestMonotonicSubarray [10, 50, 10, 10, 12, 48, 21, 5, 7, 23, 37, 29, 15, 23, 28])," 4 (longestMonotonicSubarray [10, 50, 10, 10, 12, 48, 21, 5, 7, 23, 37, 29, 15, 23, 28]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (longestMonotonicSubarray [32, 6, 23, 12, 49, 23, 29, 33, 47, 48, 7, 42, 10, 13, 2, 8, 11, 34, 7, 3, 34, 35, 10, 35, 23, 29, 12, 48, 41, 10, 40, 30])," 5 (longestMonotonicSubarray [32, 6, 23, 12, 49, 23, 29, 33, 47, 48, 7, 42, 10, 13, 2, 8, 11, 34, 7, 3, 34, 35, 10, 35, 23, 29, 12, 48, 41, 10, 40, 30]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (longestMonotonicSubarray [17, 29, 10, 39, 14, 18, 12, 3, 21, 49, 16, 42, 7, 13, 17, 38, 2, 9, 42, 22, 8, 47, 1, 27, 41, 16, 33, 23, 16, 15, 21, 22, 14, 38, 29, 28, 30, 15])," 4 (longestMonotonicSubarray [17, 29, 10, 39, 14, 18, 12, 3, 21, 49, 16, 42, 7, 13, 17, 38, 2, 9, 42, 22, 8, 47, 1, 27, 41, 16, 33, 23, 16, 15, 21, 22, 14, 38, 29, 28, 30, 15]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

longest_strictly_increasing_or_strictly_decreasing_subarray/java_tests/Main.java

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

longest_strictly_increasing_or_strictly_decreasing_subarray/meta.json

@@ -0,0 +1,225 @@
+{
+    "id": 3372,
+    "name": "longest_strictly_increasing_or_strictly_decreasing_subarray",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/longest-strictly-increasing-or-strictly-decreasing-subarray/",
+    "date": "2024-03-31 00:00:00",
+    "task_description": "You are given an array of integers `nums`. Return _the length of the **longest** subarray of _`nums`_ which is either **strictly increasing** or **strictly decreasing**_. **Example 1:** **Input:** nums = [1,4,3,3,2] **Output:** 2 **Explanation:** The strictly increasing subarrays of `nums` are `[1]`, `[2]`, `[3]`, `[3]`, `[4]`, and `[1,4]`. The strictly decreasing subarrays of `nums` are `[1]`, `[2]`, `[3]`, `[3]`, `[4]`, `[3,2]`, and `[4,3]`. Hence, we return `2`. **Example 2:** **Input:** nums = [3,3,3,3] **Output:** 1 **Explanation:** The strictly increasing subarrays of `nums` are `[3]`, `[3]`, `[3]`, and `[3]`. The strictly decreasing subarrays of `nums` are `[3]`, `[3]`, `[3]`, and `[3]`. Hence, we return `1`. **Example 3:** **Input:** nums = [3,2,1] **Output:** 3 **Explanation:** The strictly increasing subarrays of `nums` are `[3]`, `[2]`, and `[1]`. The strictly decreasing subarrays of `nums` are `[3]`, `[2]`, `[1]`, `[3,2]`, `[2,1]`, and `[3,2,1]`. Hence, we return `3`. **Constraints:** `1 <= nums.length <= 50` `1 <= nums[i] <= 50`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,4,3,3,2]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [3,3,3,3]",
+            "output": "1 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [3,2,1]",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                17,
+                11,
+                42,
+                20,
+                14,
+                23,
+                15,
+                4,
+                3,
+                27,
+                18,
+                12,
+                47,
+                36,
+                39,
+                36,
+                7,
+                4,
+                18,
+                15,
+                32,
+                7,
+                7,
+                19,
+                5,
+                31,
+                16,
+                37,
+                15,
+                19,
+                26,
+                17,
+                19,
+                42,
+                47,
+                47,
+                33
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                4,
+                41,
+                47,
+                46,
+                12,
+                46,
+                22,
+                9,
+                27,
+                11,
+                41,
+                47,
+                7,
+                21,
+                6,
+                35,
+                48,
+                47,
+                39,
+                30,
+                12,
+                50,
+                36,
+                16,
+                36,
+                23,
+                3,
+                34,
+                21,
+                4,
+                48,
+                11,
+                22,
+                13,
+                27,
+                40,
+                47,
+                46,
+                20,
+                3,
+                4,
+                46,
+                13,
+                50,
+                8,
+                6
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                10,
+                50,
+                10,
+                10,
+                12,
+                48,
+                21,
+                5,
+                7,
+                23,
+                37,
+                29,
+                15,
+                23,
+                28
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                32,
+                6,
+                23,
+                12,
+                49,
+                23,
+                29,
+                33,
+                47,
+                48,
+                7,
+                42,
+                10,
+                13,
+                2,
+                8,
+                11,
+                34,
+                7,
+                3,
+                34,
+                35,
+                10,
+                35,
+                23,
+                29,
+                12,
+                48,
+                41,
+                10,
+                40,
+                30
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                17,
+                29,
+                10,
+                39,
+                14,
+                18,
+                12,
+                3,
+                21,
+                49,
+                16,
+                42,
+                7,
+                13,
+                17,
+                38,
+                2,
+                9,
+                42,
+                22,
+                8,
+                47,
+                1,
+                27,
+                41,
+                16,
+                33,
+                23,
+                16,
+                15,
+                21,
+                22,
+                14,
+                38,
+                29,
+                28,
+                30,
+                15
+            ],
+            "output": 4
+        }
+    ],
+    "haskell_template": "longestMonotonicSubarray :: [Int] -> Int\nlongestMonotonicSubarray nums ",
+    "ocaml_template": "let longestMonotonicSubarray (nums: int list) : int =  ",
+    "scala_template": "def longestMonotonicSubarray(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int longestMonotonicSubarray(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def longestMonotonicSubarray(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

longest_strictly_increasing_or_strictly_decreasing_subarray/ocaml_tests/main.ml

@@ -0,0 +1,45 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let longestMonotonicSubarray (nums: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (longestMonotonicSubarray [1;4;3;3;2])
+
+let test2 _ = assert_equal 1 (longestMonotonicSubarray [3;3;3;3])
+
+let test3 _ = assert_equal 3 (longestMonotonicSubarray [3;2;1])
+
+let test4 _ = assert_equal 3 (longestMonotonicSubarray [17; 11; 42; 20; 14; 23; 15; 4; 3; 27; 18; 12; 47; 36; 39; 36; 7; 4; 18; 15; 32; 7; 7; 19; 5; 31; 16; 37; 15; 19; 26; 17; 19; 42; 47; 47; 33])
+
+let test5 _ = assert_equal 3 (longestMonotonicSubarray [4; 41; 47; 46; 12; 46; 22; 9; 27; 11; 41; 47; 7; 21; 6; 35; 48; 47; 39; 30; 12; 50; 36; 16; 36; 23; 3; 34; 21; 4; 48; 11; 22; 13; 27; 40; 47; 46; 20; 3; 4; 46; 13; 50; 8; 6])
+
+let test6 _ = assert_equal 3 (longestMonotonicSubarray [10; 50; 10; 10; 12; 48; 21; 5; 7; 23; 37; 29; 15; 23; 28])
+
+let test7 _ = assert_equal 3 (longestMonotonicSubarray [32; 6; 23; 12; 49; 23; 29; 33; 47; 48; 7; 42; 10; 13; 2; 8; 11; 34; 7; 3; 34; 35; 10; 35; 23; 29; 12; 48; 41; 10; 40; 30])
+
+let test8 _ = assert_equal 3 (longestMonotonicSubarray [17; 29; 10; 39; 14; 18; 12; 3; 21; 49; 16; 42; 7; 13; 17; 38; 2; 9; 42; 22; 8; 47; 1; 27; 41; 16; 33; 23; 16; 15; 21; 22; 14; 38; 29; 28; 30; 15])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for longestMonotonicSubarray" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end