6eee26792c406aadb14f1a9f1a5570568fbd757659dfa2a1a89f4f1d3a5318b2

lexicographically_minimum_string_after_removing_stars/meta.json

@@ -0,0 +1,47 @@
+{
+    "id": 3445,
+    "name": "lexicographically_minimum_string_after_removing_stars",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/lexicographically-minimum-string-after-removing-stars/",
+    "date": "2024-05-26 00:00:00",
+    "task_description": "You are given a string `s`. It may contain any number of `'*'` characters. Your task is to remove all `'*'` characters. While there is a `'*'`, do the following operation: Delete the leftmost `'*'` and the **smallest** non-`'*'` character to its _left_. If there are several smallest characters, you can delete any of them. Return the lexicographically smallest resulting string after removing all `'*'` characters. **Example 1:** **Input:** s = \"aaba*\" **Output:** \"aab\" **Explanation:** We should delete one of the `'a'` characters with `'*'`. If we choose `s[3]`, `s` becomes the lexicographically smallest. **Example 2:** **Input:** s = \"abc\" **Output:** \"abc\" **Explanation:** There is no `'*'` in the string. **Constraints:** `1 <= s.length <= 105` `s` consists only of lowercase English letters and `'*'`. The input is generated such that it is possible to delete all `'*'` characters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"aaba*\"",
+            "output": "\"aab\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"abc\"",
+            "output": "\"abc\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "em*wg*f**ybr*l*pab*qibci**lb*a*iem**fa*hdovwy*azsxhmnldzu**vy*chsph**mrpcspuiykrgeevj*n***c*",
+            "output": "wyrpqiilimhovwyzsxhmnlzuvyhspmrpspuiykrvjn"
+        },
+        {
+            "input": "***v**tn**yz*ue*posifv**x*b*p****vskqa*zt*s***uo*nt*iaod**d",
+            "output": "zvxvztutiod"
+        },
+        {
+            "input": "*eu*i*crro****pdthvkhfmb*cgrqdimoujhvszay**wjwo",
+            "output": "updthvkhfmgrqdimoujhvszywjwo"
+        },
+        {
+            "input": "ydmb*****vxtav*",
+            "output": "vxtv"
+        },
+        {
+            "input": "ehonlvmymghwllsifhqtogjtfqywhmaafqeywuweabozqlx",
+            "output": "ehonlvmymghwllsifhqtogjtfqywhmaafqeywuweabozqlx"
+        }
+    ],
+    "haskell_template": "clearStars :: String -> String\nclearStars s ",
+    "ocaml_template": "let clearStars (s: string) : string =  ",
+    "scala_template": "def clearStars(s: String): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String clearStars(String s) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def clearStars(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: str\n        \"\"\"\n        "
+}

lexicographically_minimum_string_after_removing_stars/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let clearStars (s: string) : string =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "aab" (clearStars "aaba*")
+
+let test2 _ = assert_equal "abc" (clearStars "abc")
+
+let test3 _ = assert_equal "abc" (clearStars "em*wg*f**ybr*l*pab*qibci**lb*a*iem**fa*hdovwy*azsxhmnldzu**vy*chsph**mrpcspuiykrgeevj*n***c*")
+
+let test4 _ = assert_equal "abc" (clearStars "***v**tn**yz*ue*posifv**x*b*p****vskqa*zt*s***uo*nt*iaod**d")
+
+let test5 _ = assert_equal "abc" (clearStars "*eu*i*crro****pdthvkhfmb*cgrqdimoujhvszay**wjwo")
+
+let test6 _ = assert_equal "abc" (clearStars "ydmb*****vxtav*")
+
+let test7 _ = assert_equal "abc" (clearStars "ehonlvmymghwllsifhqtogjtfqywhmaafqeywuweabozqlx")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for clearStars" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

lexicographically_minimum_string_after_removing_stars/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.clearStars("aaba*"), "aab")
+  }
+
+  test("test2") {
+    assertEquals(Main.clearStars("abc"), "abc")
+  }
+
+  test("test3") {
+    assertEquals(Main.clearStars(",e,m,*,w,g,*,f,*,*,y,b,r,*,l,*,p,a,b,*,q,i,b,c,i,*,*,l,b,*,a,*,i,e,m,*,*,f,a,*,h,d,o,v,w,y,*,a,z,s,x,h,m,n,l,d,z,u,*,*,v,y,*,c,h,s,p,h,*,*,m,r,p,c,s,p,u,i,y,k,r,g,e,e,v,j,*,n,*,*,*,c,*,"), "wyrpqiilimhovwyzsxhmnlzuvyhspmrpspuiykrvjn")
+  }
+
+  test("test4") {
+    assertEquals(Main.clearStars(",*,*,*,v,*,*,t,n,*,*,y,z,*,u,e,*,p,o,s,i,f,v,*,*,x,*,b,*,p,*,*,*,*,v,s,k,q,a,*,z,t,*,s,*,*,*,u,o,*,n,t,*,i,a,o,d,*,*,d,"), "zvxvztutiod")
+  }
+
+  test("test5") {
+    assertEquals(Main.clearStars(",*,e,u,*,i,*,c,r,r,o,*,*,*,*,p,d,t,h,v,k,h,f,m,b,*,c,g,r,q,d,i,m,o,u,j,h,v,s,z,a,y,*,*,w,j,w,o,"), "updthvkhfmgrqdimoujhvszywjwo")
+  }
+
+  test("test6") {
+    assertEquals(Main.clearStars(",y,d,m,b,*,*,*,*,*,v,x,t,a,v,*,"), "vxtv")
+  }
+
+  test("test7") {
+    assertEquals(Main.clearStars(",e,h,o,n,l,v,m,y,m,g,h,w,l,l,s,i,f,h,q,t,o,g,j,t,f,q,y,w,h,m,a,a,f,q,e,y,w,u,w,e,a,b,o,z,q,l,x,"), "ehonlvmymghwllsifhqtogjtfqywhmaafqeywuweabozqlx")
+  }
+
+}

lexicographically_smallest_beautiful_string/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 (smallestBeautifulString \"abcz \" 26)," "abda" (smallestBeautifulString "abcz" 26))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (smallestBeautifulString \"dc \" 4)," "" (smallestBeautifulString "dc" 4))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

lexicographically_smallest_beautiful_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("26", smallestBeautifulString("abcz", 26));
+}
+@Test
+public void test2() {
+    assertEquals("4", smallestBeautifulString("dc", 4));
+}
+
+}

lexicographically_smallest_beautiful_string/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2687,
+    "name": "lexicographically_smallest_beautiful_string",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/lexicographically-smallest-beautiful-string/",
+    "date": "1682208000000",
+    "task_description": "A string is **beautiful** if: It consists of the first `k` letters of the English lowercase alphabet. It does not contain any substring of length `2` or more which is a palindrome. You are given a beautiful string `s` of length `n` and a positive integer `k`. Return _the lexicographically smallest string of length _`n`_, which is larger than _`s`_ and is **beautiful**_. If there is no such string, return an empty string. A string `a` is lexicographically larger than a string `b` (of the same length) if in the first position where `a` and `b` differ, `a` has a character strictly larger than the corresponding character in `b`. For example, `\"abcd\"` is lexicographically larger than `\"abcc\"` because the first position they differ is at the fourth character, and `d` is greater than `c`. **Example 1:** ``` **Input:** s = \"abcz\", k = 26 **Output:** \"abda\" **Explanation:** The string \"abda\" is beautiful and lexicographically larger than the string \"abcz\". It can be proven that there is no string that is lexicographically larger than the string \"abcz\", beautiful, and lexicographically smaller than the string \"abda\". ``` **Example 2:** ``` **Input:** s = \"dc\", k = 4 **Output:** \"\" **Explanation:** It can be proven that there is no string that is lexicographically larger than the string \"dc\" and is beautiful. ``` **Constraints:** `1 <= n == s.length <= 105` `4 <= k <= 26` `s` is a beautiful string.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"abcz\", k = 26",
+            "output": "\"abda\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"dc\", k = 4",
+            "output": "\"\" "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "smallestBeautifulString :: String -> Int -> String\nsmallestBeautifulString s k ",
+    "ocaml_template": "let smallestBeautifulString (s: string) (k: int) : string =  ",
+    "scala_template": "def smallestBeautifulString(s: String,k: Int): String = { \n    \n}",
+    "java_template": "public static String smallestBeautifulString(String s, int k) {\n\n}",
+    "python_template": "class Solution(object):\n    def smallestBeautifulString(self, s, k):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :rtype: str\n        \"\"\"\n        "
+}

lexicographically_smallest_beautiful_string/ocaml_tests/main.ml

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

lexicographically_smallest_beautiful_string/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.smallestBeautifulString("abcz",26), "abda")
+  }
+
+  test("test2") {
+    assertEquals(Main.smallestBeautifulString("dc",4), "")
+  }
+
+}

lexicographically_smallest_generated_string/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals("ab", generateString("TFTF", "ab"));
+}
+@Test
+public void test2() {
+    assertEquals("abc", generateString("TFTF", "abc"));
+}
+@Test
+public void test3() {
+    assertEquals("d", generateString("F", "d"));
+}
+
+}

lexicographically_smallest_palindrome/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+makeSmallestPalindrome :: String -> String
+makeSmallestPalindrome s = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (makeSmallestPalindrome \"egcfe \")," "efcfe" (makeSmallestPalindrome "egcfe"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (makeSmallestPalindrome \"abcd \")," "abba" (makeSmallestPalindrome "abcd"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (makeSmallestPalindrome \"seven \")," "neven" (makeSmallestPalindrome "seven"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (makeSmallestPalindrome  \"ambdznuydmjfhqcgfpuhtjrrydrqhtralekhdfinhznilnjq \")," "ajbdinuhdifdhkcgapthqjdrrdjqhtpagckhdfidhunidbja" (makeSmallestPalindrome "ambdznuydmjfhqcgfpuhtjrrydrqhtralekhdfinhznilnjq"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (makeSmallestPalindrome  \"yitjlmpdttfsujkjvvjtothhlnalgbugleblbxkndttmtvceeqhcgvzezeaykbcxlnocmuofwxecdbxbndimpctxcxjzwfgayqsdavruxprxsgafgicxcpqxpebxcgsfpiuluxlwcpwquqmijingphfwmusgndcelsmgrkaiwfgblllhhqqbksermmpgvklqyheovdnvckrwzmjqipnwxfaasphyazriaokkylhmsmgghkceakwsinnksicbcvqaufudshhsqefiggrvedykjpmjnebyriqnppzeilctkctnrhrudctlclcgfibkfesqcjffbsyfaxsrztsuihjsasrbwfihsfytracpquzamgrwoakqeoxbskilnrpqcnefiykskszofphrphswivglaxafypbfyyghqvitarztimoculhmqmcqfovwssekqeszllcbjwtisgmnqygybpihahhzpqihwazlysuuzlsspgpyjlfplvehlspmlyagivxvyejcxcjdztacetggpgqtdbmguethgkllhegaoqklewkwbmnfwbjtgelbdzfjoctvguvnlagoksbmpdvhrxjysxobfmifpskndpwsozhlsmcfmygtbczxxmzginnhbxgwvibcufdufuvfxrkmahxqaqxsyf \")," "fisjlapdhafkrjfjufjdftcbinaggbhgleblbxkncbtgtmcceqhcgosepdakkbcilfbcmsofwrecdbmbndigacnvcgjtcfgaydbdagrjbpfnmbafgeckcoageeblcghfeiglbdlqcpggtecajidgchcjeusgndcallmgrkaevfgbljlhgpqbksermmlgakhiqhehhahicbrgymjmgpitwfaallhsaqkeaokkofhcmmgghkceaitsianisicbcvfapffasahgqefiggrhedokjkmjnebencqnpnleilbtkcqkahrrdcalclccaibkfehicjbfbasfaisrttrsiafsabfbjcihefkbiacclclacdrrhakqcktblielnpnqcnebenjmkjkodehrggifeqghasaffpafvcbcisinaistiaeckhggmmchfokkoaekqashllaafwtipgmjmygrbcihahhehqihkaglmmreskbqpghljlbgfveakrgmllacdngsuejchcgdijacetggpcqldblgiefhgclbeegaockcegfabmnfpbjrgadbdyagfctjgcvncagidnbmbdcerwfosmcbflicbkkadpesogchqeccmtgtbcnkxblbelghbgganibctfdjfujfjrkfahdpaljsif" (makeSmallestPalindrome "yitjlmpdttfsujkjvvjtothhlnalgbugleblbxkndttmtvceeqhcgvzezeaykbcxlnocmuofwxecdbxbndimpctxcxjzwfgayqsdavruxprxsgafgicxcpqxpebxcgsfpiuluxlwcpwquqmijingphfwmusgndcelsmgrkaiwfgblllhhqqbksermmpgvklqyheovdnvckrwzmjqipnwxfaasphyazriaokkylhmsmgghkceakwsinnksicbcvqaufudshhsqefiggrvedykjpmjnebyriqnppzeilctkctnrhrudctlclcgfibkfesqcjffbsyfaxsrztsuihjsasrbwfihsfytracpquzamgrwoakqeoxbskilnrpqcnefiykskszofphrphswivglaxafypbfyyghqvitarztimoculhmqmcqfovwssekqeszllcbjwtisgmnqygybpihahhzpqihwazlysuuzlsspgpyjlfplvehlspmlyagivxvyejcxcjdztacetggpgqtdbmguethgkllhegaoqklewkwbmnfwbjtgelbdzfjoctvguvnlagoksbmpdvhrxjysxobfmifpskndpwsozhlsmcfmygtbczxxmzginnhbxgwvibcufdufuvfxrkmahxqaqxsyf"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (makeSmallestPalindrome  \"wsmyzvvwfwvynwkbgyrmhhxlbzlotyhxgftzqixzfehhpyctifudibmykwxhjmfajpazzntgtahkyjjwzxismfvthzsoxtenuixmtqgmvtmilfkgaqbnapyiwikbtnloizxazaamlofjhuycsxzzmgzjgwhjltoobhdrrkjujtlxkgzuibrfvgjmdgcknxvnukcfyebzwvdamqaqzrpdxlrhuwxtbqnhvulihbmhyqkcadzystcyqywgmzpbatibagphaejovoiwahmfrdwzqqckcuhfcvwffpvsiyhyuiyzmxhtqrfkhspkyzgmxinpeutpuxbvpvfuirjinikrryeobkuadlack \")," "kcaldaukboeynrkbgijmhhflbvbotphuefniqigzfehhhkcrifhdibmikwhhimfaffavcfhgcackqjjdrfihafiohojeahegabimabgmmgmilfcgaqbdackiwhkbhiloihnabaamlhfjhdpcsqaqmadjgwbelfckbhdrnkcgdmjgkfrbibrfkgjmdgcknrdhbkcflebwgjdamqaqscpdhjfhlmaabanhiolihbkhwikcadbqagcflimgmmgbamibagehaejohoifahifrdjjqkcacghfcvaffafmihhwkimbidhfirckhhhefzgiqinfeuhptobvblfhhmjigbkrnyeobkuadlack" (makeSmallestPalindrome "wsmyzvvwfwvynwkbgyrmhhxlbzlotyhxgftzqixzfehhpyctifudibmykwxhjmfajpazzntgtahkyjjwzxismfvthzsoxtenuixmtqgmvtmilfkgaqbnapyiwikbtnloizxazaamlofjhuycsxzzmgzjgwhjltoobhdrrkjujtlxkgzuibrfvgjmdgcknxvnukcfyebzwvdamqaqzrpdxlrhuwxtbqnhvulihbmhyqkcadzystcyqywgmzpbatibagphaejovoiwahmfrdwzqqckcuhfcvwffpvsiyhyuiyzmxhtqrfkhspkyzgmxinpeutpuxbvpvfuirjinikrryeobkuadlack"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (makeSmallestPalindrome  \"ihyrpkzaorwjlfrkxdbvmicylwwmsbdboqgfkcphplzgpwynvbbpsdnntvtrwzcmdxfmokmvrzucnftjcjmifvzlwudczyedjhohdmiftarkxtsmjxngnmjvyuqveraemtxempakaziyeewrguxxjslqdimsuoxabultcnsabsminivncjrmzvsagujvpmnnuvtoipwmecqfkfwpqddlterisakointsxcjubxkveoeczwtyewraeujavtbvvmekktmqavojsvylncgtwcugozsbthskkpkotszgsfzlvzmkvkfnjfqttftzqqguofjfensrzcgcztnnapszujakvefhyndlghzetvqaesstuvpfbdboygpkeawotbpyjsjihcjbzkbeswxsoilrmgrbptcsumttsgbwihfyzzeajvgfasmnejvjakjdclorldemyybmgjqxexzmuvrihliymhcjrhalmglcuhrmvtszwrvswdysyozhhvnriolieiuwxjavenkxbojtjoltehsydtxm \")," "ihtdpkhaolojlfobxdbemacxluieibdbongfhcohpldgpvrnvbbpmdhnclgmlacmdcfmoilhirucmftecjjgfbylmedcroecdhkadmienarafgsjaengnfhiwbgseraemctebpakalioeewrebkxbjchdimjuobabuaecngabbdbfivncjreaqsaeuhgldnnhfeoiajmecpakftpcdclrenefafoigqqxcftbqfjefeckmtvewfaeujaokbkkmekbsmoaucjsgcllcgsjcuaomsbkemkkbkoajueafwevtmkcefejfqbtfcxqqgiofafenerlcdcptfkapcemjaioefhnndlghueasqaerjcnvifbdbbagnceaubaboujmidhcjbxkberweeoilakapbetcmearesgbwihfngneajsgfaraneimdakhdceorcdemlybfgjjcetfmcurihliomfcdmcalmglcnhdmpbbvnrvpgdlphochfgnobdbieiulxcamebdxbofljoloahkpdthi" (makeSmallestPalindrome "ihyrpkzaorwjlfrkxdbvmicylwwmsbdboqgfkcphplzgpwynvbbpsdnntvtrwzcmdxfmokmvrzucnftjcjmifvzlwudczyedjhohdmiftarkxtsmjxngnmjvyuqveraemtxempakaziyeewrguxxjslqdimsuoxabultcnsabsminivncjrmzvsagujvpmnnuvtoipwmecqfkfwpqddlterisakointsxcjubxkveoeczwtyewraeujavtbvvmekktmqavojsvylncgtwcugozsbthskkpkotszgsfzlvzmkvkfnjfqttftzqqguofjfensrzcgcztnnapszujakvefhyndlghzetvqaesstuvpfbdboygpkeawotbpyjsjihcjbzkbeswxsoilrmgrbptcsumttsgbwihfyzzeajvgfasmnejvjakjdclorldemyybmgjqxexzmuvrihliymhcjrhalmglcuhrmvtszwrvswdysyozhhvnriolieiuwxjavenkxbojtjoltehsydtxm"))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (makeSmallestPalindrome  \"yekczcvprfcuoqmsrpvbaepgbtmbrdlcoypkebbzshkkvuaqkdrnjsurhqixaorprkmkdutmjjkeqihqgfpomvjneqkpsgzkwpoxdiedczejnphlecdhrlmvcwakybxzhohqhddhgtgjikbaxfaxktzyihfsjtikaycptfgeucjnengavxdlrstaowjtficdumjgczwdfkjtxieqnzzybapowztnrwiqalxtwqkzxgeopwgdijoebtcypnlzzjttiyyfeuygflifwgoudefganizhvtspstzzjpsazdiobypyadsihttpuuiqyspslmnsblzogcchilqrbmgwovomynkihergmmiayisokxdueuiczyaracnhqhnpxztqcydajjzihrldndgsgvriijbmpuqiqskexcannnhdinstounyfgydoedebipauegnlpekasgjjigavmuutagnuzitoqoxbvcacyuonvxfsrboikzpujjctgbjmbpwjeksnyzwkutnzdmybhlpqlezssjpmvzlkpkkprixoicolikdagrkunrkdlphpukqqjcjlxrvcxamowdqocfjkaqmthcqufkkguyfutwxyfpwkfrpsftbgqbsxynhsyduxesjybykecmbdjmygmrrtpinofjhstyqwpoxntocrrvrczzbwbjaoocgzzajasnyvkhguiuvmnknugtyiwfrplcmjxhfauumjbfdhnnxyyeiqbuizhzdeuybsuqmcfmerjiexceccmddafwojvhirvqtrsfowtigscsuthbebcwgvuaeikhdlfppkqmnhsuunxjlpagbqfhidhpslxqmnbwbgdiwyptnzdijqmklievnhvmzoxbxeilcwpxwnkmcakqxgbvdyvtlbsobwuodrvzz \")," "yekcdcupbfcblqmsdpbbaekabmkbrdlcclieebboshkhnuaikdmnjidrhqixaidgbkbkdqtljjhdihfqbfaoljjneqkhngqkppfldhedcaejgpcbebdhrlcsciakobsrhohqhddhgtfaddbaceaxeijrehfcjqikaycedfgeicbneegavndhdfbamujafhcdmcjgcfwdfkgtniemnuiubakownsajaiqacooajbwbgecpvgdcjoebocwpnlshjfoiipfermgflidbgcedebganexhdtshntxsbpgatdiobfkwadsihttfuugkkfpqchnmbakjfcchdlomamcvovljcjkihepgmldariskkgadeiicciaracnhkhklxvmpcsdaejqihhbdmdgngukiijbmkejipbkebcacjjhdikiobrnffgndoecabibaoegnipekaagjjigagijjgaakepingeoabibaceodngffnrboikidhjjcacbekbpijekmbjiikugngdmdbhhiqjeadscpmvxlkhkhncaraicciiedagkksiradlmgpehikjcjlvovcmamoldhccfjkabmnhcqpfkkguuftthisdawkfboidtagpbsxtnhstdhxenagbedecgbdilfgmrefpiiofjhslnpwcobeojcdgvpcegbwbjaoocaqiajasnwokabuiunmeintgkfdwfcgjcmdchfajumabfdhdnvageenbciegfdecyakiqjcfherjiexaecabddaftghddhqhohrsbokaicsclrhdbebcpgjeacdehdlfppkqgnhkqenjjloafbqfhidhjjltqdkbkbgdiaxiqhrdijnmdkiaunhkhsobbeeilccldrbkmbakeabbpdsmqlbcfbpucdckey" (makeSmallestPalindrome "yekczcvprfcuoqmsrpvbaepgbtmbrdlcoypkebbzshkkvuaqkdrnjsurhqixaorprkmkdutmjjkeqihqgfpomvjneqkpsgzkwpoxdiedczejnphlecdhrlmvcwakybxzhohqhddhgtgjikbaxfaxktzyihfsjtikaycptfgeucjnengavxdlrstaowjtficdumjgczwdfkjtxieqnzzybapowztnrwiqalxtwqkzxgeopwgdijoebtcypnlzzjttiyyfeuygflifwgoudefganizhvtspstzzjpsazdiobypyadsihttpuuiqyspslmnsblzogcchilqrbmgwovomynkihergmmiayisokxdueuiczyaracnhqhnpxztqcydajjzihrldndgsgvriijbmpuqiqskexcannnhdinstounyfgydoedebipauegnlpekasgjjigavmuutagnuzitoqoxbvcacyuonvxfsrboikzpujjctgbjmbpwjeksnyzwkutnzdmybhlpqlezssjpmvzlkpkkprixoicolikdagrkunrkdlphpukqqjcjlxrvcxamowdqocfjkaqmthcqufkkguyfutwxyfpwkfrpsftbgqbsxynhsyduxesjybykecmbdjmygmrrtpinofjhstyqwpoxntocrrvrczzbwbjaoocgzzajasnyvkhguiuvmnknugtyiwfrplcmjxhfauumjbfdhnnxyyeiqbuizhzdeuybsuqmcfmerjiexceccmddafwojvhirvqtrsfowtigscsuthbebcwgvuaeikhdlfppkqmnhsuunxjlpagbqfhidhpslxqmnbwbgdiwyptnzdijqmklievnhvmzoxbxeilcwpxwnkmcakqxgbvdyvtlbsobwuodrvzz"))
+
+
+-- 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

lexicographically_smallest_palindrome/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("egcfe", makeSmallestPalindrome("egcfe"));
+}
+@Test
+public void test2() {
+    assertEquals("abcd", makeSmallestPalindrome("abcd"));
+}
+@Test
+public void test3() {
+    assertEquals("seven", makeSmallestPalindrome("seven"));
+}
+
+}

lexicographically_smallest_palindrome/meta.json

@@ -0,0 +1,52 @@
+{
+    "id": 2816,
+    "name": "lexicographically_smallest_palindrome",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/lexicographically-smallest-palindrome/",
+    "date": "2023-05-14 00:00:00",
+    "task_description": "You are given a string `s` consisting of **lowercase English letters**, and you are allowed to perform operations on it. In one operation, you can **replace** a character in `s` with another lowercase English letter. Your task is to make `s` a **palindrome** with the **minimum** **number** **of operations** possible. If there are **multiple palindromes** that can be made using the **minimum** number of operations, make the **lexicographically smallest** one. A string `a` is lexicographically smaller than a string `b` (of the same length) if in the first position where `a` and `b` differ, string `a` has a letter that appears earlier in the alphabet than the corresponding letter in `b`. Return _the resulting palindrome string._ **Example 1:** ``` **Input:** s = \"egcfe\" **Output:** \"efcfe\" **Explanation:** The minimum number of operations to make \"egcfe\" a palindrome is 1, and the lexicographically smallest palindrome string we can get by modifying one character is \"efcfe\", by changing 'g'. ``` **Example 2:** ``` **Input:** s = \"abcd\" **Output:** \"abba\" **Explanation:** The minimum number of operations to make \"abcd\" a palindrome is 2, and the lexicographically smallest palindrome string we can get by modifying two characters is \"abba\". ``` **Example 3:** ``` **Input:** s = \"seven\" **Output:** \"neven\" **Explanation:** The minimum number of operations to make \"seven\" a palindrome is 1, and the lexicographically smallest palindrome string we can get by modifying one character is \"neven\". ``` **Constraints:** `1 <= s.length <= 1000` `s` consists of only lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"egcfe\"",
+            "output": "\"efcfe\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"abcd\"",
+            "output": "\"abba\" "
+        },
+        {
+            "label": "Example 3",
+            "input": "s = \"seven\"",
+            "output": "\"neven\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "ambdznuydmjfhqcgfpuhtjrrydrqhtralekhdfinhznilnjq",
+            "output": "ajbdinuhdifdhkcgapthqjdrrdjqhtpagckhdfidhunidbja"
+        },
+        {
+            "input": "yitjlmpdttfsujkjvvjtothhlnalgbugleblbxkndttmtvceeqhcgvzezeaykbcxlnocmuofwxecdbxbndimpctxcxjzwfgayqsdavruxprxsgafgicxcpqxpebxcgsfpiuluxlwcpwquqmijingphfwmusgndcelsmgrkaiwfgblllhhqqbksermmpgvklqyheovdnvckrwzmjqipnwxfaasphyazriaokkylhmsmgghkceakwsinnksicbcvqaufudshhsqefiggrvedykjpmjnebyriqnppzeilctkctnrhrudctlclcgfibkfesqcjffbsyfaxsrztsuihjsasrbwfihsfytracpquzamgrwoakqeoxbskilnrpqcnefiykskszofphrphswivglaxafypbfyyghqvitarztimoculhmqmcqfovwssekqeszllcbjwtisgmnqygybpihahhzpqihwazlysuuzlsspgpyjlfplvehlspmlyagivxvyejcxcjdztacetggpgqtdbmguethgkllhegaoqklewkwbmnfwbjtgelbdzfjoctvguvnlagoksbmpdvhrxjysxobfmifpskndpwsozhlsmcfmygtbczxxmzginnhbxgwvibcufdufuvfxrkmahxqaqxsyf",
+            "output": "fisjlapdhafkrjfjufjdftcbinaggbhgleblbxkncbtgtmcceqhcgosepdakkbcilfbcmsofwrecdbmbndigacnvcgjtcfgaydbdagrjbpfnmbafgeckcoageeblcghfeiglbdlqcpggtecajidgchcjeusgndcallmgrkaevfgbljlhgpqbksermmlgakhiqhehhahicbrgymjmgpitwfaallhsaqkeaokkofhcmmgghkceaitsianisicbcvfapffasahgqefiggrhedokjkmjnebencqnpnleilbtkcqkahrrdcalclccaibkfehicjbfbasfaisrttrsiafsabfbjcihefkbiacclclacdrrhakqcktblielnpnqcnebenjmkjkodehrggifeqghasaffpafvcbcisinaistiaeckhggmmchfokkoaekqashllaafwtipgmjmygrbcihahhehqihkaglmmreskbqpghljlbgfveakrgmllacdngsuejchcgdijacetggpcqldblgiefhgclbeegaockcegfabmnfpbjrgadbdyagfctjgcvncagidnbmbdcerwfosmcbflicbkkadpesogchqeccmtgtbcnkxblbelghbgganibctfdjfujfjrkfahdpaljsif"
+        },
+        {
+            "input": "wsmyzvvwfwvynwkbgyrmhhxlbzlotyhxgftzqixzfehhpyctifudibmykwxhjmfajpazzntgtahkyjjwzxismfvthzsoxtenuixmtqgmvtmilfkgaqbnapyiwikbtnloizxazaamlofjhuycsxzzmgzjgwhjltoobhdrrkjujtlxkgzuibrfvgjmdgcknxvnukcfyebzwvdamqaqzrpdxlrhuwxtbqnhvulihbmhyqkcadzystcyqywgmzpbatibagphaejovoiwahmfrdwzqqckcuhfcvwffpvsiyhyuiyzmxhtqrfkhspkyzgmxinpeutpuxbvpvfuirjinikrryeobkuadlack",
+            "output": "kcaldaukboeynrkbgijmhhflbvbotphuefniqigzfehhhkcrifhdibmikwhhimfaffavcfhgcackqjjdrfihafiohojeahegabimabgmmgmilfcgaqbdackiwhkbhiloihnabaamlhfjhdpcsqaqmadjgwbelfckbhdrnkcgdmjgkfrbibrfkgjmdgcknrdhbkcflebwgjdamqaqscpdhjfhlmaabanhiolihbkhwikcadbqagcflimgmmgbamibagehaejohoifahifrdjjqkcacghfcvaffafmihhwkimbidhfirckhhhefzgiqinfeuhptobvblfhhmjigbkrnyeobkuadlack"
+        },
+        {
+            "input": "ihyrpkzaorwjlfrkxdbvmicylwwmsbdboqgfkcphplzgpwynvbbpsdnntvtrwzcmdxfmokmvrzucnftjcjmifvzlwudczyedjhohdmiftarkxtsmjxngnmjvyuqveraemtxempakaziyeewrguxxjslqdimsuoxabultcnsabsminivncjrmzvsagujvpmnnuvtoipwmecqfkfwpqddlterisakointsxcjubxkveoeczwtyewraeujavtbvvmekktmqavojsvylncgtwcugozsbthskkpkotszgsfzlvzmkvkfnjfqttftzqqguofjfensrzcgcztnnapszujakvefhyndlghzetvqaesstuvpfbdboygpkeawotbpyjsjihcjbzkbeswxsoilrmgrbptcsumttsgbwihfyzzeajvgfasmnejvjakjdclorldemyybmgjqxexzmuvrihliymhcjrhalmglcuhrmvtszwrvswdysyozhhvnriolieiuwxjavenkxbojtjoltehsydtxm",
+            "output": "ihtdpkhaolojlfobxdbemacxluieibdbongfhcohpldgpvrnvbbpmdhnclgmlacmdcfmoilhirucmftecjjgfbylmedcroecdhkadmienarafgsjaengnfhiwbgseraemctebpakalioeewrebkxbjchdimjuobabuaecngabbdbfivncjreaqsaeuhgldnnhfeoiajmecpakftpcdclrenefafoigqqxcftbqfjefeckmtvewfaeujaokbkkmekbsmoaucjsgcllcgsjcuaomsbkemkkbkoajueafwevtmkcefejfqbtfcxqqgiofafenerlcdcptfkapcemjaioefhnndlghueasqaerjcnvifbdbbagnceaubaboujmidhcjbxkberweeoilakapbetcmearesgbwihfngneajsgfaraneimdakhdceorcdemlybfgjjcetfmcurihliomfcdmcalmglcnhdmpbbvnrvpgdlphochfgnobdbieiulxcamebdxbofljoloahkpdthi"
+        },
+        {
+            "input": "yekczcvprfcuoqmsrpvbaepgbtmbrdlcoypkebbzshkkvuaqkdrnjsurhqixaorprkmkdutmjjkeqihqgfpomvjneqkpsgzkwpoxdiedczejnphlecdhrlmvcwakybxzhohqhddhgtgjikbaxfaxktzyihfsjtikaycptfgeucjnengavxdlrstaowjtficdumjgczwdfkjtxieqnzzybapowztnrwiqalxtwqkzxgeopwgdijoebtcypnlzzjttiyyfeuygflifwgoudefganizhvtspstzzjpsazdiobypyadsihttpuuiqyspslmnsblzogcchilqrbmgwovomynkihergmmiayisokxdueuiczyaracnhqhnpxztqcydajjzihrldndgsgvriijbmpuqiqskexcannnhdinstounyfgydoedebipauegnlpekasgjjigavmuutagnuzitoqoxbvcacyuonvxfsrboikzpujjctgbjmbpwjeksnyzwkutnzdmybhlpqlezssjpmvzlkpkkprixoicolikdagrkunrkdlphpukqqjcjlxrvcxamowdqocfjkaqmthcqufkkguyfutwxyfpwkfrpsftbgqbsxynhsyduxesjybykecmbdjmygmrrtpinofjhstyqwpoxntocrrvrczzbwbjaoocgzzajasnyvkhguiuvmnknugtyiwfrplcmjxhfauumjbfdhnnxyyeiqbuizhzdeuybsuqmcfmerjiexceccmddafwojvhirvqtrsfowtigscsuthbebcwgvuaeikhdlfppkqmnhsuunxjlpagbqfhidhpslxqmnbwbgdiwyptnzdijqmklievnhvmzoxbxeilcwpxwnkmcakqxgbvdyvtlbsobwuodrvzz",
+            "output": "yekcdcupbfcblqmsdpbbaekabmkbrdlcclieebboshkhnuaikdmnjidrhqixaidgbkbkdqtljjhdihfqbfaoljjneqkhngqkppfldhedcaejgpcbebdhrlcsciakobsrhohqhddhgtfaddbaceaxeijrehfcjqikaycedfgeicbneegavndhdfbamujafhcdmcjgcfwdfkgtniemnuiubakownsajaiqacooajbwbgecpvgdcjoebocwpnlshjfoiipfermgflidbgcedebganexhdtshntxsbpgatdiobfkwadsihttfuugkkfpqchnmbakjfcchdlomamcvovljcjkihepgmldariskkgadeiicciaracnhkhklxvmpcsdaejqihhbdmdgngukiijbmkejipbkebcacjjhdikiobrnffgndoecabibaoegnipekaagjjigagijjgaakepingeoabibaceodngffnrboikidhjjcacbekbpijekmbjiikugngdmdbhhiqjeadscpmvxlkhkhncaraicciiedagkksiradlmgpehikjcjlvovcmamoldhccfjkabmnhcqpfkkguuftthisdawkfboidtagpbsxtnhstdhxenagbedecgbdilfgmrefpiiofjhslnpwcobeojcdgvpcegbwbjaoocaqiajasnwokabuiunmeintgkfdwfcgjcmdchfajumabfdhdnvageenbciegfdecyakiqjcfherjiexaecabddaftghddhqhohrsbokaicsclrhdbebcpgjeacdehdlfppkqgnhkqenjjloafbqfhidhjjltqdkbkbgdiaxiqhrdijnmdkiaunhkhsobbeeilccldrbkmbakeabbpdsmqlbcfbpucdckey"
+        }
+    ],
+    "haskell_template": "makeSmallestPalindrome :: String -> String\nmakeSmallestPalindrome s ",
+    "ocaml_template": "let makeSmallestPalindrome (s: string) : string =  ",
+    "scala_template": "def makeSmallestPalindrome(s: String): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String makeSmallestPalindrome(String s) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def makeSmallestPalindrome(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: str\n        \"\"\"\n        "
+}

lexicographically_smallest_palindrome/ocaml_tests/main.ml

@@ -0,0 +1,45 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let makeSmallestPalindrome (s: string) : string =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "efcfe" (makeSmallestPalindrome "egcfe")
+
+let test2 _ = assert_equal "abba" (makeSmallestPalindrome "abcd")
+
+let test3 _ = assert_equal "neven" (makeSmallestPalindrome "seven")
+
+let test4 _ = assert_equal "neven" (makeSmallestPalindrome "ambdznuydmjfhqcgfpuhtjrrydrqhtralekhdfinhznilnjq")
+
+let test5 _ = assert_equal "neven" (makeSmallestPalindrome "yitjlmpdttfsujkjvvjtothhlnalgbugleblbxkndttmtvceeqhcgvzezeaykbcxlnocmuofwxecdbxbndimpctxcxjzwfgayqsdavruxprxsgafgicxcpqxpebxcgsfpiuluxlwcpwquqmijingphfwmusgndcelsmgrkaiwfgblllhhqqbksermmpgvklqyheovdnvckrwzmjqipnwxfaasphyazriaokkylhmsmgghkceakwsinnksicbcvqaufudshhsqefiggrvedykjpmjnebyriqnppzeilctkctnrhrudctlclcgfibkfesqcjffbsyfaxsrztsuihjsasrbwfihsfytracpquzamgrwoakqeoxbskilnrpqcnefiykskszofphrphswivglaxafypbfyyghqvitarztimoculhmqmcqfovwssekqeszllcbjwtisgmnqygybpihahhzpqihwazlysuuzlsspgpyjlfplvehlspmlyagivxvyejcxcjdztacetggpgqtdbmguethgkllhegaoqklewkwbmnfwbjtgelbdzfjoctvguvnlagoksbmpdvhrxjysxobfmifpskndpwsozhlsmcfmygtbczxxmzginnhbxgwvibcufdufuvfxrkmahxqaqxsyf")
+
+let test6 _ = assert_equal "neven" (makeSmallestPalindrome "wsmyzvvwfwvynwkbgyrmhhxlbzlotyhxgftzqixzfehhpyctifudibmykwxhjmfajpazzntgtahkyjjwzxismfvthzsoxtenuixmtqgmvtmilfkgaqbnapyiwikbtnloizxazaamlofjhuycsxzzmgzjgwhjltoobhdrrkjujtlxkgzuibrfvgjmdgcknxvnukcfyebzwvdamqaqzrpdxlrhuwxtbqnhvulihbmhyqkcadzystcyqywgmzpbatibagphaejovoiwahmfrdwzqqckcuhfcvwffpvsiyhyuiyzmxhtqrfkhspkyzgmxinpeutpuxbvpvfuirjinikrryeobkuadlack")
+
+let test7 _ = assert_equal "neven" (makeSmallestPalindrome "ihyrpkzaorwjlfrkxdbvmicylwwmsbdboqgfkcphplzgpwynvbbpsdnntvtrwzcmdxfmokmvrzucnftjcjmifvzlwudczyedjhohdmiftarkxtsmjxngnmjvyuqveraemtxempakaziyeewrguxxjslqdimsuoxabultcnsabsminivncjrmzvsagujvpmnnuvtoipwmecqfkfwpqddlterisakointsxcjubxkveoeczwtyewraeujavtbvvmekktmqavojsvylncgtwcugozsbthskkpkotszgsfzlvzmkvkfnjfqttftzqqguofjfensrzcgcztnnapszujakvefhyndlghzetvqaesstuvpfbdboygpkeawotbpyjsjihcjbzkbeswxsoilrmgrbptcsumttsgbwihfyzzeajvgfasmnejvjakjdclorldemyybmgjqxexzmuvrihliymhcjrhalmglcuhrmvtszwrvswdysyozhhvnriolieiuwxjavenkxbojtjoltehsydtxm")
+
+let test8 _ = assert_equal "neven" (makeSmallestPalindrome "yekczcvprfcuoqmsrpvbaepgbtmbrdlcoypkebbzshkkvuaqkdrnjsurhqixaorprkmkdutmjjkeqihqgfpomvjneqkpsgzkwpoxdiedczejnphlecdhrlmvcwakybxzhohqhddhgtgjikbaxfaxktzyihfsjtikaycptfgeucjnengavxdlrstaowjtficdumjgczwdfkjtxieqnzzybapowztnrwiqalxtwqkzxgeopwgdijoebtcypnlzzjttiyyfeuygflifwgoudefganizhvtspstzzjpsazdiobypyadsihttpuuiqyspslmnsblzogcchilqrbmgwovomynkihergmmiayisokxdueuiczyaracnhqhnpxztqcydajjzihrldndgsgvriijbmpuqiqskexcannnhdinstounyfgydoedebipauegnlpekasgjjigavmuutagnuzitoqoxbvcacyuonvxfsrboikzpujjctgbjmbpwjeksnyzwkutnzdmybhlpqlezssjpmvzlkpkkprixoicolikdagrkunrkdlphpukqqjcjlxrvcxamowdqocfjkaqmthcqufkkguyfutwxyfpwkfrpsftbgqbsxynhsyduxesjybykecmbdjmygmrrtpinofjhstyqwpoxntocrrvrczzbwbjaoocgzzajasnyvkhguiuvmnknugtyiwfrplcmjxhfauumjbfdhnnxyyeiqbuizhzdeuybsuqmcfmerjiexceccmddafwojvhirvqtrsfowtigscsuthbebcwgvuaeikhdlfppkqmnhsuunxjlpagbqfhidhpslxqmnbwbgdiwyptnzdijqmklievnhvmzoxbxeilcwpxwnkmcakqxgbvdyvtlbsobwuodrvzz")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for makeSmallestPalindrome" >::: [
+        
+  "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

lexicographically_smallest_palindrome/scala_tests/MySuite.scala

@@ -0,0 +1,36 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.makeSmallestPalindrome("egcfe"), "efcfe")
+  }
+
+  test("test2") {
+    assertEquals(Main.makeSmallestPalindrome("abcd"), "abba")
+  }
+
+  test("test3") {
+    assertEquals(Main.makeSmallestPalindrome("seven"), "neven")
+  }
+
+  test("test4") {
+    assertEquals(Main.makeSmallestPalindrome(",a,m,b,d,z,n,u,y,d,m,j,f,h,q,c,g,f,p,u,h,t,j,r,r,y,d,r,q,h,t,r,a,l,e,k,h,d,f,i,n,h,z,n,i,l,n,j,q,"), "ajbdinuhdifdhkcgapthqjdrrdjqhtpagckhdfidhunidbja")
+  }
+
+  test("test5") {
+    assertEquals(Main.makeSmallestPalindrome(",y,i,t,j,l,m,p,d,t,t,f,s,u,j,k,j,v,v,j,t,o,t,h,h,l,n,a,l,g,b,u,g,l,e,b,l,b,x,k,n,d,t,t,m,t,v,c,e,e,q,h,c,g,v,z,e,z,e,a,y,k,b,c,x,l,n,o,c,m,u,o,f,w,x,e,c,d,b,x,b,n,d,i,m,p,c,t,x,c,x,j,z,w,f,g,a,y,q,s,d,a,v,r,u,x,p,r,x,s,g,a,f,g,i,c,x,c,p,q,x,p,e,b,x,c,g,s,f,p,i,u,l,u,x,l,w,c,p,w,q,u,q,m,i,j,i,n,g,p,h,f,w,m,u,s,g,n,d,c,e,l,s,m,g,r,k,a,i,w,f,g,b,l,l,l,h,h,q,q,b,k,s,e,r,m,m,p,g,v,k,l,q,y,h,e,o,v,d,n,v,c,k,r,w,z,m,j,q,i,p,n,w,x,f,a,a,s,p,h,y,a,z,r,i,a,o,k,k,y,l,h,m,s,m,g,g,h,k,c,e,a,k,w,s,i,n,n,k,s,i,c,b,c,v,q,a,u,f,u,d,s,h,h,s,q,e,f,i,g,g,r,v,e,d,y,k,j,p,m,j,n,e,b,y,r,i,q,n,p,p,z,e,i,l,c,t,k,c,t,n,r,h,r,u,d,c,t,l,c,l,c,g,f,i,b,k,f,e,s,q,c,j,f,f,b,s,y,f,a,x,s,r,z,t,s,u,i,h,j,s,a,s,r,b,w,f,i,h,s,f,y,t,r,a,c,p,q,u,z,a,m,g,r,w,o,a,k,q,e,o,x,b,s,k,i,l,n,r,p,q,c,n,e,f,i,y,k,s,k,s,z,o,f,p,h,r,p,h,s,w,i,v,g,l,a,x,a,f,y,p,b,f,y,y,g,h,q,v,i,t,a,r,z,t,i,m,o,c,u,l,h,m,q,m,c,q,f,o,v,w,s,s,e,k,q,e,s,z,l,l,c,b,j,w,t,i,s,g,m,n,q,y,g,y,b,p,i,h,a,h,h,z,p,q,i,h,w,a,z,l,y,s,u,u,z,l,s,s,p,g,p,y,j,l,f,p,l,v,e,h,l,s,p,m,l,y,a,g,i,v,x,v,y,e,j,c,x,c,j,d,z,t,a,c,e,t,g,g,p,g,q,t,d,b,m,g,u,e,t,h,g,k,l,l,h,e,g,a,o,q,k,l,e,w,k,w,b,m,n,f,w,b,j,t,g,e,l,b,d,z,f,j,o,c,t,v,g,u,v,n,l,a,g,o,k,s,b,m,p,d,v,h,r,x,j,y,s,x,o,b,f,m,i,f,p,s,k,n,d,p,w,s,o,z,h,l,s,m,c,f,m,y,g,t,b,c,z,x,x,m,z,g,i,n,n,h,b,x,g,w,v,i,b,c,u,f,d,u,f,u,v,f,x,r,k,m,a,h,x,q,a,q,x,s,y,f,"), "fisjlapdhafkrjfjufjdftcbinaggbhgleblbxkncbtgtmcceqhcgosepdakkbcilfbcmsofwrecdbmbndigacnvcgjtcfgaydbdagrjbpfnmbafgeckcoageeblcghfeiglbdlqcpggtecajidgchcjeusgndcallmgrkaevfgbljlhgpqbksermmlgakhiqhehhahicbrgymjmgpitwfaallhsaqkeaokkofhcmmgghkceaitsianisicbcvfapffasahgqefiggrhedokjkmjnebencqnpnleilbtkcqkahrrdcalclccaibkfehicjbfbasfaisrttrsiafsabfbjcihefkbiacclclacdrrhakqcktblielnpnqcnebenjmkjkodehrggifeqghasaffpafvcbcisinaistiaeckhggmmchfokkoaekqashllaafwtipgmjmygrbcihahhehqihkaglmmreskbqpghljlbgfveakrgmllacdngsuejchcgdijacetggpcqldblgiefhgclbeegaockcegfabmnfpbjrgadbdyagfctjgcvncagidnbmbdcerwfosmcbflicbkkadpesogchqeccmtgtbcnkxblbelghbgganibctfdjfujfjrkfahdpaljsif")
+  }
+
+  test("test6") {
+    assertEquals(Main.makeSmallestPalindrome(",w,s,m,y,z,v,v,w,f,w,v,y,n,w,k,b,g,y,r,m,h,h,x,l,b,z,l,o,t,y,h,x,g,f,t,z,q,i,x,z,f,e,h,h,p,y,c,t,i,f,u,d,i,b,m,y,k,w,x,h,j,m,f,a,j,p,a,z,z,n,t,g,t,a,h,k,y,j,j,w,z,x,i,s,m,f,v,t,h,z,s,o,x,t,e,n,u,i,x,m,t,q,g,m,v,t,m,i,l,f,k,g,a,q,b,n,a,p,y,i,w,i,k,b,t,n,l,o,i,z,x,a,z,a,a,m,l,o,f,j,h,u,y,c,s,x,z,z,m,g,z,j,g,w,h,j,l,t,o,o,b,h,d,r,r,k,j,u,j,t,l,x,k,g,z,u,i,b,r,f,v,g,j,m,d,g,c,k,n,x,v,n,u,k,c,f,y,e,b,z,w,v,d,a,m,q,a,q,z,r,p,d,x,l,r,h,u,w,x,t,b,q,n,h,v,u,l,i,h,b,m,h,y,q,k,c,a,d,z,y,s,t,c,y,q,y,w,g,m,z,p,b,a,t,i,b,a,g,p,h,a,e,j,o,v,o,i,w,a,h,m,f,r,d,w,z,q,q,c,k,c,u,h,f,c,v,w,f,f,p,v,s,i,y,h,y,u,i,y,z,m,x,h,t,q,r,f,k,h,s,p,k,y,z,g,m,x,i,n,p,e,u,t,p,u,x,b,v,p,v,f,u,i,r,j,i,n,i,k,r,r,y,e,o,b,k,u,a,d,l,a,c,k,"), "kcaldaukboeynrkbgijmhhflbvbotphuefniqigzfehhhkcrifhdibmikwhhimfaffavcfhgcackqjjdrfihafiohojeahegabimabgmmgmilfcgaqbdackiwhkbhiloihnabaamlhfjhdpcsqaqmadjgwbelfckbhdrnkcgdmjgkfrbibrfkgjmdgcknrdhbkcflebwgjdamqaqscpdhjfhlmaabanhiolihbkhwikcadbqagcflimgmmgbamibagehaejohoifahifrdjjqkcacghfcvaffafmihhwkimbidhfirckhhhefzgiqinfeuhptobvblfhhmjigbkrnyeobkuadlack")
+  }
+
+  test("test7") {
+    assertEquals(Main.makeSmallestPalindrome(",i,h,y,r,p,k,z,a,o,r,w,j,l,f,r,k,x,d,b,v,m,i,c,y,l,w,w,m,s,b,d,b,o,q,g,f,k,c,p,h,p,l,z,g,p,w,y,n,v,b,b,p,s,d,n,n,t,v,t,r,w,z,c,m,d,x,f,m,o,k,m,v,r,z,u,c,n,f,t,j,c,j,m,i,f,v,z,l,w,u,d,c,z,y,e,d,j,h,o,h,d,m,i,f,t,a,r,k,x,t,s,m,j,x,n,g,n,m,j,v,y,u,q,v,e,r,a,e,m,t,x,e,m,p,a,k,a,z,i,y,e,e,w,r,g,u,x,x,j,s,l,q,d,i,m,s,u,o,x,a,b,u,l,t,c,n,s,a,b,s,m,i,n,i,v,n,c,j,r,m,z,v,s,a,g,u,j,v,p,m,n,n,u,v,t,o,i,p,w,m,e,c,q,f,k,f,w,p,q,d,d,l,t,e,r,i,s,a,k,o,i,n,t,s,x,c,j,u,b,x,k,v,e,o,e,c,z,w,t,y,e,w,r,a,e,u,j,a,v,t,b,v,v,m,e,k,k,t,m,q,a,v,o,j,s,v,y,l,n,c,g,t,w,c,u,g,o,z,s,b,t,h,s,k,k,p,k,o,t,s,z,g,s,f,z,l,v,z,m,k,v,k,f,n,j,f,q,t,t,f,t,z,q,q,g,u,o,f,j,f,e,n,s,r,z,c,g,c,z,t,n,n,a,p,s,z,u,j,a,k,v,e,f,h,y,n,d,l,g,h,z,e,t,v,q,a,e,s,s,t,u,v,p,f,b,d,b,o,y,g,p,k,e,a,w,o,t,b,p,y,j,s,j,i,h,c,j,b,z,k,b,e,s,w,x,s,o,i,l,r,m,g,r,b,p,t,c,s,u,m,t,t,s,g,b,w,i,h,f,y,z,z,e,a,j,v,g,f,a,s,m,n,e,j,v,j,a,k,j,d,c,l,o,r,l,d,e,m,y,y,b,m,g,j,q,x,e,x,z,m,u,v,r,i,h,l,i,y,m,h,c,j,r,h,a,l,m,g,l,c,u,h,r,m,v,t,s,z,w,r,v,s,w,d,y,s,y,o,z,h,h,v,n,r,i,o,l,i,e,i,u,w,x,j,a,v,e,n,k,x,b,o,j,t,j,o,l,t,e,h,s,y,d,t,x,m,"), "ihtdpkhaolojlfobxdbemacxluieibdbongfhcohpldgpvrnvbbpmdhnclgmlacmdcfmoilhirucmftecjjgfbylmedcroecdhkadmienarafgsjaengnfhiwbgseraemctebpakalioeewrebkxbjchdimjuobabuaecngabbdbfivncjreaqsaeuhgldnnhfeoiajmecpakftpcdclrenefafoigqqxcftbqfjefeckmtvewfaeujaokbkkmekbsmoaucjsgcllcgsjcuaomsbkemkkbkoajueafwevtmkcefejfqbtfcxqqgiofafenerlcdcptfkapcemjaioefhnndlghueasqaerjcnvifbdbbagnceaubaboujmidhcjbxkberweeoilakapbetcmearesgbwihfngneajsgfaraneimdakhdceorcdemlybfgjjcetfmcurihliomfcdmcalmglcnhdmpbbvnrvpgdlphochfgnobdbieiulxcamebdxbofljoloahkpdthi")
+  }
+
+  test("test8") {
+    assertEquals(Main.makeSmallestPalindrome(",y,e,k,c,z,c,v,p,r,f,c,u,o,q,m,s,r,p,v,b,a,e,p,g,b,t,m,b,r,d,l,c,o,y,p,k,e,b,b,z,s,h,k,k,v,u,a,q,k,d,r,n,j,s,u,r,h,q,i,x,a,o,r,p,r,k,m,k,d,u,t,m,j,j,k,e,q,i,h,q,g,f,p,o,m,v,j,n,e,q,k,p,s,g,z,k,w,p,o,x,d,i,e,d,c,z,e,j,n,p,h,l,e,c,d,h,r,l,m,v,c,w,a,k,y,b,x,z,h,o,h,q,h,d,d,h,g,t,g,j,i,k,b,a,x,f,a,x,k,t,z,y,i,h,f,s,j,t,i,k,a,y,c,p,t,f,g,e,u,c,j,n,e,n,g,a,v,x,d,l,r,s,t,a,o,w,j,t,f,i,c,d,u,m,j,g,c,z,w,d,f,k,j,t,x,i,e,q,n,z,z,y,b,a,p,o,w,z,t,n,r,w,i,q,a,l,x,t,w,q,k,z,x,g,e,o,p,w,g,d,i,j,o,e,b,t,c,y,p,n,l,z,z,j,t,t,i,y,y,f,e,u,y,g,f,l,i,f,w,g,o,u,d,e,f,g,a,n,i,z,h,v,t,s,p,s,t,z,z,j,p,s,a,z,d,i,o,b,y,p,y,a,d,s,i,h,t,t,p,u,u,i,q,y,s,p,s,l,m,n,s,b,l,z,o,g,c,c,h,i,l,q,r,b,m,g,w,o,v,o,m,y,n,k,i,h,e,r,g,m,m,i,a,y,i,s,o,k,x,d,u,e,u,i,c,z,y,a,r,a,c,n,h,q,h,n,p,x,z,t,q,c,y,d,a,j,j,z,i,h,r,l,d,n,d,g,s,g,v,r,i,i,j,b,m,p,u,q,i,q,s,k,e,x,c,a,n,n,n,h,d,i,n,s,t,o,u,n,y,f,g,y,d,o,e,d,e,b,i,p,a,u,e,g,n,l,p,e,k,a,s,g,j,j,i,g,a,v,m,u,u,t,a,g,n,u,z,i,t,o,q,o,x,b,v,c,a,c,y,u,o,n,v,x,f,s,r,b,o,i,k,z,p,u,j,j,c,t,g,b,j,m,b,p,w,j,e,k,s,n,y,z,w,k,u,t,n,z,d,m,y,b,h,l,p,q,l,e,z,s,s,j,p,m,v,z,l,k,p,k,k,p,r,i,x,o,i,c,o,l,i,k,d,a,g,r,k,u,n,r,k,d,l,p,h,p,u,k,q,q,j,c,j,l,x,r,v,c,x,a,m,o,w,d,q,o,c,f,j,k,a,q,m,t,h,c,q,u,f,k,k,g,u,y,f,u,t,w,x,y,f,p,w,k,f,r,p,s,f,t,b,g,q,b,s,x,y,n,h,s,y,d,u,x,e,s,j,y,b,y,k,e,c,m,b,d,j,m,y,g,m,r,r,t,p,i,n,o,f,j,h,s,t,y,q,w,p,o,x,n,t,o,c,r,r,v,r,c,z,z,b,w,b,j,a,o,o,c,g,z,z,a,j,a,s,n,y,v,k,h,g,u,i,u,v,m,n,k,n,u,g,t,y,i,w,f,r,p,l,c,m,j,x,h,f,a,u,u,m,j,b,f,d,h,n,n,x,y,y,e,i,q,b,u,i,z,h,z,d,e,u,y,b,s,u,q,m,c,f,m,e,r,j,i,e,x,c,e,c,c,m,d,d,a,f,w,o,j,v,h,i,r,v,q,t,r,s,f,o,w,t,i,g,s,c,s,u,t,h,b,e,b,c,w,g,v,u,a,e,i,k,h,d,l,f,p,p,k,q,m,n,h,s,u,u,n,x,j,l,p,a,g,b,q,f,h,i,d,h,p,s,l,x,q,m,n,b,w,b,g,d,i,w,y,p,t,n,z,d,i,j,q,m,k,l,i,e,v,n,h,v,m,z,o,x,b,x,e,i,l,c,w,p,x,w,n,k,m,c,a,k,q,x,g,b,v,d,y,v,t,l,b,s,o,b,w,u,o,d,r,v,z,z,"), "yekcdcupbfcblqmsdpbbaekabmkbrdlcclieebboshkhnuaikdmnjidrhqixaidgbkbkdqtljjhdihfqbfaoljjneqkhngqkppfldhedcaejgpcbebdhrlcsciakobsrhohqhddhgtfaddbaceaxeijrehfcjqikaycedfgeicbneegavndhdfbamujafhcdmcjgcfwdfkgtniemnuiubakownsajaiqacooajbwbgecpvgdcjoebocwpnlshjfoiipfermgflidbgcedebganexhdtshntxsbpgatdiobfkwadsihttfuugkkfpqchnmbakjfcchdlomamcvovljcjkihepgmldariskkgadeiicciaracnhkhklxvmpcsdaejqihhbdmdgngukiijbmkejipbkebcacjjhdikiobrnffgndoecabibaoegnipekaagjjigagijjgaakepingeoabibaceodngffnrboikidhjjcacbekbpijekmbjiikugngdmdbhhiqjeadscpmvxlkhkhncaraicciiedagkksiradlmgpehikjcjlvovcmamoldhccfjkabmnhcqpfkkguuftthisdawkfboidtagpbsxtnhstdhxenagbedecgbdilfgmrefpiiofjhslnpwcobeojcdgvpcegbwbjaoocaqiajasnwokabuiunmeintgkfdwfcgjcmdchfajumabfdhdnvageenbciegfdecyakiqjcfherjiexaecabddaftghddhqhohrsbokaicsclrhdbebcpgjeacdehdlfppkqgnhkqenjjloafbqfhidhjjltqdkbkbgdiaxiqhrdijnmdkiaunhkhsobbeeilccldrbkmbakeabbpdsmqlbcfbpucdckey")
+  }
+
+}

lexicographically_smallest_string_after_a_swap/haskell_tests/Main.hs

@@ -0,0 +1,26 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+getSmallestString :: String -> String
+getSmallestString s = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (getSmallestString \"45320 \")," "43520" (getSmallestString "45320"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (getSmallestString \"001 \")," "001" (getSmallestString "001"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

lexicographically_smallest_string_after_a_swap/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("45320", getSmallestString("45320"));
+}
+@Test
+public void test2() {
+    assertEquals("001", getSmallestString("001"));
+}
+
+}

lexicographically_smallest_string_after_a_swap/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 3484,
+    "name": "lexicographically_smallest_string_after_a_swap",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/lexicographically-smallest-string-after-a-swap/",
+    "date": "2024-07-07 00:00:00",
+    "task_description": "Given a string `s` containing only digits, return the lexicographically smallest string that can be obtained after swapping **adjacent** digits in `s` with the same **parity** at most **once**. Digits have the same parity if both are odd or both are even. For example, 5 and 9, as well as 2 and 4, have the same parity, while 6 and 9 do not. **Example 1:** **Input:** s = \"45320\" **Output:** \"43520\" **Explanation: ** `s[1] == '5'` and `s[2] == '3'` both have the same parity, and swapping them results in the lexicographically smallest string. **Example 2:** **Input:** s = \"001\" **Output:** \"001\" **Explanation:** There is no need to perform a swap because `s` is already the lexicographically smallest. **Constraints:** `2 <= s.length <= 100` `s` consists only of digits.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"45320\"",
+            "output": "\"43520\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"001\"",
+            "output": "\"001\" "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "getSmallestString :: String -> String\ngetSmallestString s ",
+    "ocaml_template": "let getSmallestString (s: string) : string =  ",
+    "scala_template": "def getSmallestString(s: String): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String getSmallestString(String s) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def getSmallestString(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: str\n        \"\"\"\n        "
+}

lexicographically_smallest_string_after_a_swap/ocaml_tests/main.ml

@@ -0,0 +1,27 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let getSmallestString (s: string) : string =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "43520" (getSmallestString "45320")
+
+let test2 _ = assert_equal "001" (getSmallestString "001")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for getSmallestString" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

lexicographically_smallest_string_after_a_swap/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.getSmallestString("45320"), "43520")
+  }
+
+  test("test2") {
+    assertEquals(Main.getSmallestString("001"), "001")
+  }
+
+}

lexicographically_smallest_string_after_substring_operation/java_tests/Main.java

@@ -0,0 +1,28 @@
+
+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("cbabc", smallestString("cbabc"));
+}
+@Test
+public void test2() {
+    assertEquals("aa", smallestString("aa"));
+}
+@Test
+public void test3() {
+    assertEquals("acbbc", smallestString("acbbc"));
+}
+@Test
+public void test4() {
+    assertEquals("leetcode", smallestString("leetcode"));
+}
+
+}

longest_alternating_subarray/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+alternatingSubarray :: [Int] -> Int
+alternatingSubarray nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (alternatingSubarray [2,3,4,3,4])," 4 (alternatingSubarray [2,3,4,3,4]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (alternatingSubarray [4,5,6])," 2 (alternatingSubarray [4,5,6]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (alternatingSubarray [54, 16, 32, 95, 67, 55, 86, 56, 31, 70, 16, 68, 90, 20, 43, 33, 67, 50, 75, 12, 55, 63, 26, 45, 31, 55, 17, 20, 83, 34, 63, 51, 82, 103, 88, 88, 8, 66, 76, 85, 93, 24, 4, 70, 5, 40, 46, 99, 88, 88, 8, 40, 58, 22, 39, 37, 39, 92, 29, 26, 44, 90, 38, 15, 48, 77, 76, 10, 96, 7, 26, 7, 95, 93])," (-1) (alternatingSubarray [54, 16, 32, 95, 67, 55, 86, 56, 31, 70, 16, 68, 90, 20, 43, 33, 67, 50, 75, 12, 55, 63, 26, 45, 31, 55, 17, 20, 83, 34, 63, 51, 82, 103, 88, 88, 8, 66, 76, 85, 93, 24, 4, 70, 5, 40, 46, 99, 88, 88, 8, 40, 58, 22, 39, 37, 39, 92, 29, 26, 44, 90, 38, 15, 48, 77, 76, 10, 96, 7, 26, 7, 95, 93]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (alternatingSubarray [62, 77, 25, 40, 7, 16, 33, 76, 103, 72, 89, 50, 18, 58, 45, 28, 50, 88, 43, 65, 46, 100, 29, 65, 27, 29, 25, 8, 2, 33, 62, 34, 14, 20, 20, 40, 87, 75, 49, 53, 65, 87, 30, 100, 38, 9, 72, 86, 44, 10, 41, 53, 92, 99, 102, 14, 47, 34])," (-1) (alternatingSubarray [62, 77, 25, 40, 7, 16, 33, 76, 103, 72, 89, 50, 18, 58, 45, 28, 50, 88, 43, 65, 46, 100, 29, 65, 27, 29, 25, 8, 2, 33, 62, 34, 14, 20, 20, 40, 87, 75, 49, 53, 65, 87, 30, 100, 38, 9, 72, 86, 44, 10, 41, 53, 92, 99, 102, 14, 47, 34]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (alternatingSubarray [50, 30, 88, 101, 99, 23, 27, 91, 21])," (-1) (alternatingSubarray [50, 30, 88, 101, 99, 23, 27, 91, 21]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (alternatingSubarray [3, 23, 16, 46])," (-1) (alternatingSubarray [3, 23, 16, 46]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (alternatingSubarray [38, 73, 92, 36, 95, 99, 83, 14, 95, 4, 91, 89, 82, 62, 22, 40, 102, 25, 45, 88, 60, 80, 36, 104, 71, 28, 39, 44, 44, 38, 65, 14, 29, 43, 17, 18, 22, 79, 39, 98, 102, 55, 81, 25, 104, 60, 6])," 2 (alternatingSubarray [38, 73, 92, 36, 95, 99, 83, 14, 95, 4, 91, 89, 82, 62, 22, 40, 102, 25, 45, 88, 60, 80, 36, 104, 71, 28, 39, 44, 44, 38, 65, 14, 29, 43, 17, 18, 22, 79, 39, 98, 102, 55, 81, 25, 104, 60, 6]))
+
+
+-- 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

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

longest_alternating_subarray/meta.json

@@ -0,0 +1,244 @@
+{
+    "id": 2870,
+    "name": "longest_alternating_subarray",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/longest-alternating-subarray/",
+    "date": "2023-06-24 00:00:00",
+    "task_description": "You are given a **0-indexed** integer array `nums`. A subarray `s` of length `m` is called **alternating** if: `m` is greater than `1`. `s1 = s0 + 1`. The **0-indexed** subarray `s` looks like `[s0, s1, s0, s1,...,s(m-1) % 2]`. In other words, `s1 - s0 = 1`, `s2 - s1 = -1`, `s3 - s2 = 1`, `s4 - s3 = -1`, and so on up to `s[m - 1] - s[m - 2] = (-1)m`. Return _the maximum length of all **alternating** subarrays present in _`nums` _or _`-1`_ if no such subarray exists__._ A subarray is a contiguous **non-empty** sequence of elements within an array. **Example 1:** **Input:** nums = [2,3,4,3,4] **Output:** 4 **Explanation:** The alternating subarrays are `[2, 3]`, `[3,4]`, `[3,4,3]`, and `[3,4,3,4]`. The longest of these is `[3,4,3,4]`, which is of length 4. **Example 2:** **Input:** nums = [4,5,6] **Output:** 2 **Explanation:** `[4,5]` and `[5,6]` are the only two alternating subarrays. They are both of length 2. **Constraints:** `2 <= nums.length <= 100` `1 <= nums[i] <= 104`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,3,4,3,4]",
+            "output": "4 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [4,5,6]",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                54,
+                16,
+                32,
+                95,
+                67,
+                55,
+                86,
+                56,
+                31,
+                70,
+                16,
+                68,
+                90,
+                20,
+                43,
+                33,
+                67,
+                50,
+                75,
+                12,
+                55,
+                63,
+                26,
+                45,
+                31,
+                55,
+                17,
+                20,
+                83,
+                34,
+                63,
+                51,
+                82,
+                103,
+                88,
+                88,
+                8,
+                66,
+                76,
+                85,
+                93,
+                24,
+                4,
+                70,
+                5,
+                40,
+                46,
+                99,
+                88,
+                88,
+                8,
+                40,
+                58,
+                22,
+                39,
+                37,
+                39,
+                92,
+                29,
+                26,
+                44,
+                90,
+                38,
+                15,
+                48,
+                77,
+                76,
+                10,
+                96,
+                7,
+                26,
+                7,
+                95,
+                93
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                62,
+                77,
+                25,
+                40,
+                7,
+                16,
+                33,
+                76,
+                103,
+                72,
+                89,
+                50,
+                18,
+                58,
+                45,
+                28,
+                50,
+                88,
+                43,
+                65,
+                46,
+                100,
+                29,
+                65,
+                27,
+                29,
+                25,
+                8,
+                2,
+                33,
+                62,
+                34,
+                14,
+                20,
+                20,
+                40,
+                87,
+                75,
+                49,
+                53,
+                65,
+                87,
+                30,
+                100,
+                38,
+                9,
+                72,
+                86,
+                44,
+                10,
+                41,
+                53,
+                92,
+                99,
+                102,
+                14,
+                47,
+                34
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                50,
+                30,
+                88,
+                101,
+                99,
+                23,
+                27,
+                91,
+                21
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                3,
+                23,
+                16,
+                46
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                38,
+                73,
+                92,
+                36,
+                95,
+                99,
+                83,
+                14,
+                95,
+                4,
+                91,
+                89,
+                82,
+                62,
+                22,
+                40,
+                102,
+                25,
+                45,
+                88,
+                60,
+                80,
+                36,
+                104,
+                71,
+                28,
+                39,
+                44,
+                44,
+                38,
+                65,
+                14,
+                29,
+                43,
+                17,
+                18,
+                22,
+                79,
+                39,
+                98,
+                102,
+                55,
+                81,
+                25,
+                104,
+                60,
+                6
+            ],
+            "output": 2
+        }
+    ],
+    "haskell_template": "alternatingSubarray :: [Int] -> Int\nalternatingSubarray nums ",
+    "ocaml_template": "let alternatingSubarray (nums: int list) : int =  ",
+    "scala_template": "def alternatingSubarray(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int alternatingSubarray(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def alternatingSubarray(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

longest_alternating_subarray/ocaml_tests/main.ml

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

longest_alternating_subarray/scala_tests/MySuite.scala

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

longest_binary_subsequence_less_than_or_equal_to_k/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 (longestSubsequence \"1001010 \" 5)," 5 (longestSubsequence "1001010" 5))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (longestSubsequence \"00101001 \" 1)," 6 (longestSubsequence "00101001" 1))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (longestSubsequence  \"01100111100110100110100010011111000010000011100000011111111100001101110101001100000001001110100000001010110011100001011011011010001101111000000111101110011011100111011111110111101000011101000001001111110011110011000011110100100100001110111100011011011001100101011010001011110111100000011010011011010001001111000011000110010000010001000111110100100010010101101100001101101101000000001010000101111101101111100111001010101101101100101011001100111111101110101111001010111010000101110001011100101011010011100101011000010 \" 539443994)," 266 (longestSubsequence "01100111100110100110100010011111000010000011100000011111111100001101110101001100000001001110100000001010110011100001011011011010001101111000000111101110011011100111011111110111101000011101000001001111110011110011000011110100100100001110111100011011011001100101011010001011110111100000011010011011010001001111000011000110010000010001000111110100100010010101101100001101101101000000001010000101111101101111100111001010101101101100101011001100111111101110101111001010111010000101110001011100101011010011100101011000010" 539443994))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (longestSubsequence  \"001011000100001010101110001110101001001001001001010001011000101111011101001100101110110001000001111000011000110000000110100110110010100001011111111011110000111011010000000001000011110110101100011111011010100000011110000101111010111111000111110110011100001000100011001101100110101010101110011010000101010110011100000011011001010110010111101000111100101101010010111001011011001100010101000001001011111000100110000101111011001111111110010101011001101110101111010110000101100110010010111010101100111010011101011110101101111110010100010111000100110101101010001100011011100100011010101100001011000010011110110001110001111001000001011010110101110000001000001000110100110001010101001100101110011001100010001100101010001000011001100101100001001110101001101111001001111100101000101010101010111110101011000000111111100011011110100000101001100111110100000111011100110010000001100010100011011101000010001011110111 \" 898134424)," 471 (longestSubsequence "001011000100001010101110001110101001001001001001010001011000101111011101001100101110110001000001111000011000110000000110100110110010100001011111111011110000111011010000000001000011110110101100011111011010100000011110000101111010111111000111110110011100001000100011001101100110101010101110011010000101010110011100000011011001010110010111101000111100101101010010111001011011001100010101000001001011111000100110000101111011001111111110010101011001101110101111010110000101100110010010111010101100111010011101011110101101111110010100010111000100110101101010001100011011100100011010101100001011000010011110110001110001111001000001011010110101110000001000001000110100110001010101001100101110011001100010001100101010001000011001100101100001001110101001101111001001111100101000101010101010111110101011000000111111100011011110100000101001100111110100000111011100110010000001100010100011011101000010001011110111" 898134424))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (longestSubsequence  \"11011101100010010001111001100110010000100111001010000000001101111001110111011100011000101111110101001001111100101001010001111110010110101100110110010110101000001101000001011010100110111110001001111110011110000111111010111110111001110000001111011100000001000011110000001100010111000111100101111110000110000101001011011100110111111011011000010110100010011000101111000000110011001100101101010110000110010011111011000100001001100001000001001000111001100000000001110000001101101111100010100110001111111010000010000011001001010011101111011001000100100010000110000010101110000001010100101101011011110011100011110000110101101101100000000110100001001000100001101110110001110010100101110110101011001010110010100001001100111011000 \" 322144614)," 387 (longestSubsequence "11011101100010010001111001100110010000100111001010000000001101111001110111011100011000101111110101001001111100101001010001111110010110101100110110010110101000001101000001011010100110111110001001111110011110000111111010111110111001110000001111011100000001000011110000001100010111000111100101111110000110000101001011011100110111111011011000010110100010011000101111000000110011001100101101010110000110010011111011000100001001100001000001001000111001100000000001110000001101101111100010100110001111111010000010000011001001010011101111011001000100100010000110000010101110000001010100101101011011110011100011110000110101101101100000000110100001001000100001101110110001110010100101110110101011001010110010100001001100111011000" 322144614))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (longestSubsequence  \"1101101100101111110011111100101000011010001000110001110000011010100001001011100011000101110101000000101011111011000101101011110100010011000100101011000000010111100010100000001111011101110111101010001001111111110111010010100011011100111101101000100111011011011101100100111001010110110000001001011100011010010100011011001011010100001001010111011010110110001 \" 22228029)," 189 (longestSubsequence "1101101100101111110011111100101000011010001000110001110000011010100001001011100011000101110101000000101011111011000101101011110100010011000100101011000000010111100010100000001111011101110111101010001001111111110111010010100011011100111101101000100111011011011101100100111001010110110000001001011100011010010100011011001011010100001001010111011010110110001" 22228029))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (longestSubsequence  \"0101011011000001000101001111011111101000111110000110101011100001001011010011101101010010111001110000100011001001111101100010010001001111111110001111011101110101001100011110100111101110101100111111111100011000110000100001010010111000000111001010010000000000100100101001110111011101110011110001100111001001100001111010111000011000011010000111100011010110101010011101010101010011100111000011010110001101001000010100000010101000111010011100111110101100110101101001101001010010011001111101011111101100100001000000000101101110011111111111010111110010100101110000111011010000010011001001100110000010001010111010100111101011011100100110001011000010100000100011001001011101000110000100110100001010011000010000110111000100101101100110101010001101101101111111111111000001011101110 \" 938141866)," 403 (longestSubsequence "0101011011000001000101001111011111101000111110000110101011100001001011010011101101010010111001110000100011001001111101100010010001001111111110001111011101110101001100011110100111101110101100111111111100011000110000100001010010111000000111001010010000000000100100101001110111011101110011110001100111001001100001111010111000011000011010000111100011010110101010011101010101010011100111000011010110001101001000010100000010101000111010011100111110101100110101101001101001010010011001111101011111101100100001000000000101101110011111111111010111110010100101110000111011010000010011001001100110000010001010111010100111101011011100100110001011000010100000100011001001011101000110000100110100001010011000010000110111000100101101100110101010001101101101111111111111000001011101110" 938141866))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (longestSubsequence  \"0100101010100000110101011101100100110011010101110000100111000001100010011010000010000111011010101111111100101001100010000000100111010111111001011111000010101100100101100001001100100010111101000111010100100000000100010101001100010100001110101101110001001000101101100000111010101000110001110100101100100011000010000110111110101000101110000001010101110100010110001001111000100010000111011101111111001111010000001101010010111001101000 \" 896186850)," 244 (longestSubsequence "0100101010100000110101011101100100110011010101110000100111000001100010011010000010000111011010101111111100101001100010000000100111010111111001011111000010101100100101100001001100100010111101000111010100100000000100010101001100010100001110101101110001001000101101100000111010101000110001110100101100100011000010000110111110101000101110000001010101110100010110001001111000100010000111011101111111001111010000001101010010111001101000" 896186850))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (longestSubsequence  \"0100111010100101001101000111000101111111000111111110101100001000000101011101110001001101110111111000111110011001100101010110010110100000010010111010001010111100101101111001111101011001000111010100100100000010010011010001001011100000100011010111111110001011110111111001001010100100000011011010111101010101110000101000101101110101100110100000000011110011011101111011000101000000010100100001000000000000100110101011000111010111101110100110000000010111100100011110011010 \" 750151912)," 250 (longestSubsequence "0100111010100101001101000111000101111111000111111110101100001000000101011101110001001101110111111000111110011001100101010110010110100000010010111010001010111100101101111001111101011001000111010100100100000010010011010001001011100000100011010111111110001011110111111001001010100100000011011010111101010101110000101000101101110101100110100000000011110011011101111011000101000000010100100001000000000000100110101011000111010111101110100110000000010111100100011110011010" 750151912))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

longest_binary_subsequence_less_than_or_equal_to_k/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(5, longestSubsequence("1001010", 5));
+}
+@Test
+public void test2() {
+    assertEquals(6, longestSubsequence("00101001", 1));
+}
+
+}

longest_binary_subsequence_less_than_or_equal_to_k/meta.json

@@ -0,0 +1,76 @@
+{
+    "id": 2395,
+    "name": "longest_binary_subsequence_less_than_or_equal_to_k",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/longest-binary-subsequence-less-than-or-equal-to-k/",
+    "date": "2022-06-12 00:00:00",
+    "task_description": "You are given a binary string `s` and a positive integer `k`. Return _the length of the **longest** subsequence of _`s`_ that makes up a **binary** number less than or equal to_ `k`. Note: The subsequence can contain **leading zeroes**. The empty string is considered to be equal to `0`. A **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters. **Example 1:** ``` **Input:** s = \"1001010\", k = 5 **Output:** 5 **Explanation:** The longest subsequence of s that makes up a binary number less than or equal to 5 is \"00010\", as this number is equal to 2 in decimal. Note that \"00100\" and \"00101\" are also possible, which are equal to 4 and 5 in decimal, respectively. The length of this subsequence is 5, so 5 is returned. ``` **Example 2:** ``` **Input:** s = \"00101001\", k = 1 **Output:** 6 **Explanation:** \"000001\" is the longest subsequence of s that makes up a binary number less than or equal to 1, as this number is equal to 1 in decimal. The length of this subsequence is 6, so 6 is returned. ``` **Constraints:** `1 <= s.length <= 1000` `s[i]` is either `'0'` or `'1'`. `1 <= k <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"1001010\", k = 5",
+            "output": "5 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"00101001\", k = 1",
+            "output": "6 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"01100111100110100110100010011111000010000011100000011111111100001101110101001100000001001110100000001010110011100001011011011010001101111000000111101110011011100111011111110111101000011101000001001111110011110011000011110100100100001110111100011011011001100101011010001011110111100000011010011011010001001111000011000110010000010001000111110100100010010101101100001101101101000000001010000101111101101111100111001010101101101100101011001100111111101110101111001010111010000101110001011100101011010011100101011000010\"",
+                539443994
+            ],
+            "output": 266
+        },
+        {
+            "input": [
+                "\"001011000100001010101110001110101001001001001001010001011000101111011101001100101110110001000001111000011000110000000110100110110010100001011111111011110000111011010000000001000011110110101100011111011010100000011110000101111010111111000111110110011100001000100011001101100110101010101110011010000101010110011100000011011001010110010111101000111100101101010010111001011011001100010101000001001011111000100110000101111011001111111110010101011001101110101111010110000101100110010010111010101100111010011101011110101101111110010100010111000100110101101010001100011011100100011010101100001011000010011110110001110001111001000001011010110101110000001000001000110100110001010101001100101110011001100010001100101010001000011001100101100001001110101001101111001001111100101000101010101010111110101011000000111111100011011110100000101001100111110100000111011100110010000001100010100011011101000010001011110111\"",
+                898134424
+            ],
+            "output": 471
+        },
+        {
+            "input": [
+                "\"11011101100010010001111001100110010000100111001010000000001101111001110111011100011000101111110101001001111100101001010001111110010110101100110110010110101000001101000001011010100110111110001001111110011110000111111010111110111001110000001111011100000001000011110000001100010111000111100101111110000110000101001011011100110111111011011000010110100010011000101111000000110011001100101101010110000110010011111011000100001001100001000001001000111001100000000001110000001101101111100010100110001111111010000010000011001001010011101111011001000100100010000110000010101110000001010100101101011011110011100011110000110101101101100000000110100001001000100001101110110001110010100101110110101011001010110010100001001100111011000\"",
+                322144614
+            ],
+            "output": 387
+        },
+        {
+            "input": [
+                "\"1101101100101111110011111100101000011010001000110001110000011010100001001011100011000101110101000000101011111011000101101011110100010011000100101011000000010111100010100000001111011101110111101010001001111111110111010010100011011100111101101000100111011011011101100100111001010110110000001001011100011010010100011011001011010100001001010111011010110110001\"",
+                22228029
+            ],
+            "output": 189
+        },
+        {
+            "input": [
+                "\"0101011011000001000101001111011111101000111110000110101011100001001011010011101101010010111001110000100011001001111101100010010001001111111110001111011101110101001100011110100111101110101100111111111100011000110000100001010010111000000111001010010000000000100100101001110111011101110011110001100111001001100001111010111000011000011010000111100011010110101010011101010101010011100111000011010110001101001000010100000010101000111010011100111110101100110101101001101001010010011001111101011111101100100001000000000101101110011111111111010111110010100101110000111011010000010011001001100110000010001010111010100111101011011100100110001011000010100000100011001001011101000110000100110100001010011000010000110111000100101101100110101010001101101101111111111111000001011101110\"",
+                938141866
+            ],
+            "output": 403
+        },
+        {
+            "input": [
+                "\"0100101010100000110101011101100100110011010101110000100111000001100010011010000010000111011010101111111100101001100010000000100111010111111001011111000010101100100101100001001100100010111101000111010100100000000100010101001100010100001110101101110001001000101101100000111010101000110001110100101100100011000010000110111110101000101110000001010101110100010110001001111000100010000111011101111111001111010000001101010010111001101000\"",
+                896186850
+            ],
+            "output": 244
+        },
+        {
+            "input": [
+                "\"0100111010100101001101000111000101111111000111111110101100001000000101011101110001001101110111111000111110011001100101010110010110100000010010111010001010111100101101111001111101011001000111010100100100000010010011010001001011100000100011010111111110001011110111111001001010100100000011011010111101010101110000101000101101110101100110100000000011110011011101111011000101000000010100100001000000000000100110101011000111010111101110100110000000010111100100011110011010\"",
+                750151912
+            ],
+            "output": 250
+        }
+    ],
+    "haskell_template": "longestSubsequence :: String -> Int -> Int\nlongestSubsequence s k ",
+    "ocaml_template": "let longestSubsequence (s: string) (k: int) : int =  ",
+    "scala_template": "def longestSubsequence(s: String,k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int longestSubsequence(String s, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def longestSubsequence(self, s, k):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

longest_binary_subsequence_less_than_or_equal_to_k/ocaml_tests/main.ml

@@ -0,0 +1,47 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 5 (longestSubsequence "1001010" 5)
+
+let test2 _ = assert_equal 6 (longestSubsequence "00101001" 1)
+
+let test3 _ = assert_equal 266 (longestSubsequence "01100111100110100110100010011111000010000011100000011111111100001101110101001100000001001110100000001010110011100001011011011010001101111000000111101110011011100111011111110111101000011101000001001111110011110011000011110100100100001110111100011011011001100101011010001011110111100000011010011011010001001111000011000110010000010001000111110100100010010101101100001101101101000000001010000101111101101111100111001010101101101100101011001100111111101110101111001010111010000101110001011100101011010011100101011000010" 539443994)
+
+let test4 _ = assert_equal 471 (longestSubsequence "001011000100001010101110001110101001001001001001010001011000101111011101001100101110110001000001111000011000110000000110100110110010100001011111111011110000111011010000000001000011110110101100011111011010100000011110000101111010111111000111110110011100001000100011001101100110101010101110011010000101010110011100000011011001010110010111101000111100101101010010111001011011001100010101000001001011111000100110000101111011001111111110010101011001101110101111010110000101100110010010111010101100111010011101011110101101111110010100010111000100110101101010001100011011100100011010101100001011000010011110110001110001111001000001011010110101110000001000001000110100110001010101001100101110011001100010001100101010001000011001100101100001001110101001101111001001111100101000101010101010111110101011000000111111100011011110100000101001100111110100000111011100110010000001100010100011011101000010001011110111" 898134424)
+
+let test5 _ = assert_equal 387 (longestSubsequence "11011101100010010001111001100110010000100111001010000000001101111001110111011100011000101111110101001001111100101001010001111110010110101100110110010110101000001101000001011010100110111110001001111110011110000111111010111110111001110000001111011100000001000011110000001100010111000111100101111110000110000101001011011100110111111011011000010110100010011000101111000000110011001100101101010110000110010011111011000100001001100001000001001000111001100000000001110000001101101111100010100110001111111010000010000011001001010011101111011001000100100010000110000010101110000001010100101101011011110011100011110000110101101101100000000110100001001000100001101110110001110010100101110110101011001010110010100001001100111011000" 322144614)
+
+let test6 _ = assert_equal 189 (longestSubsequence "1101101100101111110011111100101000011010001000110001110000011010100001001011100011000101110101000000101011111011000101101011110100010011000100101011000000010111100010100000001111011101110111101010001001111111110111010010100011011100111101101000100111011011011101100100111001010110110000001001011100011010010100011011001011010100001001010111011010110110001" 22228029)
+
+let test7 _ = assert_equal 403 (longestSubsequence "0101011011000001000101001111011111101000111110000110101011100001001011010011101101010010111001110000100011001001111101100010010001001111111110001111011101110101001100011110100111101110101100111111111100011000110000100001010010111000000111001010010000000000100100101001110111011101110011110001100111001001100001111010111000011000011010000111100011010110101010011101010101010011100111000011010110001101001000010100000010101000111010011100111110101100110101101001101001010010011001111101011111101100100001000000000101101110011111111111010111110010100101110000111011010000010011001001100110000010001010111010100111101011011100100110001011000010100000100011001001011101000110000100110100001010011000010000110111000100101101100110101010001101101101111111111111000001011101110" 938141866)
+
+let test8 _ = assert_equal 244 (longestSubsequence "0100101010100000110101011101100100110011010101110000100111000001100010011010000010000111011010101111111100101001100010000000100111010111111001011111000010101100100101100001001100100010111101000111010100100000000100010101001100010100001110101101110001001000101101100000111010101000110001110100101100100011000010000110111110101000101110000001010101110100010110001001111000100010000111011101111111001111010000001101010010111001101000" 896186850)
+
+let test9 _ = assert_equal 250 (longestSubsequence "0100111010100101001101000111000101111111000111111110101100001000000101011101110001001101110111111000111110011001100101010110010110100000010010111010001010111100101101111001111101011001000111010100100100000010010011010001001011100000100011010111111110001011110111111001001010100100000011011010111101010101110000101000101101110101100110100000000011110011011101111011000101000000010100100001000000000000100110101011000111010111101110100110000000010111100100011110011010" 750151912)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for longestSubsequence" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+  "test9" >:: test9;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

longest_binary_subsequence_less_than_or_equal_to_k/scala_tests/MySuite.scala

@@ -0,0 +1,40 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.longestSubsequence("1001010",5), 5)
+  }
+
+  test("test2") {
+    assertEquals(Main.longestSubsequence("00101001",1), 6)
+  }
+
+  test("test3") {
+    assertEquals(Main.longestSubsequence("01100111100110100110100010011111000010000011100000011111111100001101110101001100000001001110100000001010110011100001011011011010001101111000000111101110011011100111011111110111101000011101000001001111110011110011000011110100100100001110111100011011011001100101011010001011110111100000011010011011010001001111000011000110010000010001000111110100100010010101101100001101101101000000001010000101111101101111100111001010101101101100101011001100111111101110101111001010111010000101110001011100101011010011100101011000010",539443994), 266)
+  }
+
+  test("test4") {
+    assertEquals(Main.longestSubsequence("001011000100001010101110001110101001001001001001010001011000101111011101001100101110110001000001111000011000110000000110100110110010100001011111111011110000111011010000000001000011110110101100011111011010100000011110000101111010111111000111110110011100001000100011001101100110101010101110011010000101010110011100000011011001010110010111101000111100101101010010111001011011001100010101000001001011111000100110000101111011001111111110010101011001101110101111010110000101100110010010111010101100111010011101011110101101111110010100010111000100110101101010001100011011100100011010101100001011000010011110110001110001111001000001011010110101110000001000001000110100110001010101001100101110011001100010001100101010001000011001100101100001001110101001101111001001111100101000101010101010111110101011000000111111100011011110100000101001100111110100000111011100110010000001100010100011011101000010001011110111",898134424), 471)
+  }
+
+  test("test5") {
+    assertEquals(Main.longestSubsequence("11011101100010010001111001100110010000100111001010000000001101111001110111011100011000101111110101001001111100101001010001111110010110101100110110010110101000001101000001011010100110111110001001111110011110000111111010111110111001110000001111011100000001000011110000001100010111000111100101111110000110000101001011011100110111111011011000010110100010011000101111000000110011001100101101010110000110010011111011000100001001100001000001001000111001100000000001110000001101101111100010100110001111111010000010000011001001010011101111011001000100100010000110000010101110000001010100101101011011110011100011110000110101101101100000000110100001001000100001101110110001110010100101110110101011001010110010100001001100111011000",322144614), 387)
+  }
+
+  test("test6") {
+    assertEquals(Main.longestSubsequence("1101101100101111110011111100101000011010001000110001110000011010100001001011100011000101110101000000101011111011000101101011110100010011000100101011000000010111100010100000001111011101110111101010001001111111110111010010100011011100111101101000100111011011011101100100111001010110110000001001011100011010010100011011001011010100001001010111011010110110001",22228029), 189)
+  }
+
+  test("test7") {
+    assertEquals(Main.longestSubsequence("0101011011000001000101001111011111101000111110000110101011100001001011010011101101010010111001110000100011001001111101100010010001001111111110001111011101110101001100011110100111101110101100111111111100011000110000100001010010111000000111001010010000000000100100101001110111011101110011110001100111001001100001111010111000011000011010000111100011010110101010011101010101010011100111000011010110001101001000010100000010101000111010011100111110101100110101101001101001010010011001111101011111101100100001000000000101101110011111111111010111110010100101110000111011010000010011001001100110000010001010111010100111101011011100100110001011000010100000100011001001011101000110000100110100001010011000010000110111000100101101100110101010001101101101111111111111000001011101110",938141866), 403)
+  }
+
+  test("test8") {
+    assertEquals(Main.longestSubsequence("0100101010100000110101011101100100110011010101110000100111000001100010011010000010000111011010101111111100101001100010000000100111010111111001011111000010101100100101100001001100100010111101000111010100100000000100010101001100010100001110101101110001001000101101100000111010101000110001110100101100100011000010000110111110101000101110000001010101110100010110001001111000100010000111011101111111001111010000001101010010111001101000",896186850), 244)
+  }
+
+  test("test9") {
+    assertEquals(Main.longestSubsequence("0100111010100101001101000111000101111111000111111110101100001000000101011101110001001101110111111000111110011001100101010110010110100000010010111010001010111100101101111001111101011001000111010100100100000010010011010001001011100000100011010111111110001011110111111001001010100100000011011010111101010101110000101000101101110101100110100000000011110011011101111011000101000000010100100001000000000000100110101011000111010111101110100110000000010111100100011110011010",750151912), 250)
+  }
+
+}

longest_even_odd_subarray_with_threshold/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 (longestAlternatingSubarray [3,2,5,4] 5)," 3 (longestAlternatingSubarray [3,2,5,4] 5))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (longestAlternatingSubarray [1,2] 2)," 1 (longestAlternatingSubarray [1,2] 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (longestAlternatingSubarray [2,3,4,5] 4)," 3 (longestAlternatingSubarray [2,3,4,5] 4))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (longestAlternatingSubarray [53, 12, 16, 68, 39, 99, 81, 24, 65, 67, 59, 84, 17, 39, 42, 1, 87, 59, 34, 41] 60)," 2 (longestAlternatingSubarray [53, 12, 16, 68, 39, 99, 81, 24, 65, 67, 59, 84, 17, 39, 42, 1, 87, 59, 34, 41] 60))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (longestAlternatingSubarray [93, 15, 82, 51, 33, 7, 29, 37, 40, 29, 71, 75, 5, 63, 16, 29, 34, 16, 61, 96, 17, 76, 76, 19, 69, 70, 61, 14, 29, 10, 37] 16)," 1 (longestAlternatingSubarray [93, 15, 82, 51, 33, 7, 29, 37, 40, 29, 71, 75, 5, 63, 16, 29, 34, 16, 61, 96, 17, 76, 76, 19, 69, 70, 61, 14, 29, 10, 37] 16))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (longestAlternatingSubarray [5, 89, 86, 41, 61, 81, 6, 24, 48, 36, 58, 2, 76, 25, 18, 51, 75, 1, 51, 7, 43, 9, 30, 30, 41, 41, 11, 79] 49)," 2 (longestAlternatingSubarray [5, 89, 86, 41, 61, 81, 6, 24, 48, 36, 58, 2, 76, 25, 18, 51, 75, 1, 51, 7, 43, 9, 30, 30, 41, 41, 11, 79] 49))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (longestAlternatingSubarray [76, 86, 22, 69, 47, 36, 46, 12, 56, 6, 77, 30, 77, 36, 65, 10, 32, 48, 62, 75, 58, 65, 39, 3, 9, 21, 24, 68, 93, 6, 34, 80, 84, 5, 4, 70, 5, 46, 30] 79)," 7 (longestAlternatingSubarray [76, 86, 22, 69, 47, 36, 46, 12, 56, 6, 77, 30, 77, 36, 65, 10, 32, 48, 62, 75, 58, 65, 39, 3, 9, 21, 24, 68, 93, 6, 34, 80, 84, 5, 4, 70, 5, 46, 30] 79))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (longestAlternatingSubarray [7, 49, 35, 59, 41, 43, 27, 60, 13, 47, 39, 16, 56, 74, 76, 87, 17, 61, 30, 9, 99, 99, 42, 25, 18, 95, 56, 86, 41, 87, 53, 87, 32, 25, 87, 62, 58, 60, 71, 74, 16, 67, 76, 85, 78, 23, 10, 4, 96, 96, 57, 46] 45)," 3 (longestAlternatingSubarray [7, 49, 35, 59, 41, 43, 27, 60, 13, 47, 39, 16, 56, 74, 76, 87, 17, 61, 30, 9, 99, 99, 42, 25, 18, 95, 56, 86, 41, 87, 53, 87, 32, 25, 87, 62, 58, 60, 71, 74, 16, 67, 76, 85, 78, 23, 10, 4, 96, 96, 57, 46] 45))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (longestAlternatingSubarray [50, 2, 70, 95, 9, 66, 2, 82, 95, 84, 33, 65, 44, 66, 83, 17, 1, 29, 92, 8, 96, 100, 6, 74, 96, 71, 78, 73, 53, 9, 45, 79, 90, 57, 72, 49, 87, 79, 80, 67, 50, 68, 89, 15, 89, 39, 45, 51, 52, 59, 21, 12, 87, 74, 52, 30, 47, 23, 23, 56, 62, 13, 16, 51, 96, 64, 18, 12, 71, 22, 39, 95, 48, 4, 39, 42, 78, 59, 11] 39)," 2 (longestAlternatingSubarray [50, 2, 70, 95, 9, 66, 2, 82, 95, 84, 33, 65, 44, 66, 83, 17, 1, 29, 92, 8, 96, 100, 6, 74, 96, 71, 78, 73, 53, 9, 45, 79, 90, 57, 72, 49, 87, 79, 80, 67, 50, 68, 89, 15, 89, 39, 45, 51, 52, 59, 21, 12, 87, 74, 52, 30, 47, 23, 23, 56, 62, 13, 16, 51, 96, 64, 18, 12, 71, 22, 39, 95, 48, 4, 39, 42, 78, 59, 11] 39))
+
+
+-- 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_even_odd_subarray_with_threshold/java_tests/Main.java

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

longest_even_odd_subarray_with_threshold/meta.json

@@ -0,0 +1,631 @@
+{
+    "id": 2866,
+    "name": "longest_even_odd_subarray_with_threshold",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/longest-even-odd-subarray-with-threshold/",
+    "date": "2023-06-25 00:00:00",
+    "task_description": "You are given a **0-indexed** integer array `nums` and an integer `threshold`. Find the length of the **longest subarray** of `nums` starting at index `l` and ending at index `r` `(0 <= l <= r < nums.length)` that satisfies the following conditions: `nums[l] % 2 == 0` For all indices `i` in the range `[l, r - 1]`, `nums[i] % 2 != nums[i + 1] % 2` For all indices `i` in the range `[l, r]`, `nums[i] <= threshold` Return _an integer denoting the length of the longest such subarray._ **Note:** A **subarray** is a contiguous non-empty sequence of elements within an array. **Example 1:** ``` **Input:** nums = [3,2,5,4], threshold = 5 **Output:** 3 **Explanation:** In this example, we can select the subarray that starts at l = 1 and ends at r = 3 => [2,5,4]. This subarray satisfies the conditions. Hence, the answer is the length of the subarray, 3. We can show that 3 is the maximum possible achievable length. ``` **Example 2:** ``` **Input:** nums = [1,2], threshold = 2 **Output:** 1 **Explanation:** In this example, we can select the subarray that starts at l = 1 and ends at r = 1 => [2]. It satisfies all the conditions and we can show that 1 is the maximum possible achievable length. ``` **Example 3:** ``` **Input:** nums = [2,3,4,5], threshold = 4 **Output:** 3 **Explanation:** In this example, we can select the subarray that starts at l = 0 and ends at r = 2 => [2,3,4]. It satisfies all the conditions. Hence, the answer is the length of the subarray, 3. We can show that 3 is the maximum possible achievable length. ``` **Constraints:** `1 <= nums.length <= 100 ` `1 <= nums[i] <= 100 ` `1 <= threshold <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [3,2,5,4], threshold = 5",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,2], threshold = 2",
+            "output": "1 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [2,3,4,5], threshold = 4",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    53,
+                    12,
+                    16,
+                    68,
+                    39,
+                    99,
+                    81,
+                    24,
+                    65,
+                    67,
+                    59,
+                    84,
+                    17,
+                    39,
+                    42,
+                    1,
+                    87,
+                    59,
+                    34,
+                    41
+                ],
+                60
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    93,
+                    15,
+                    82,
+                    51,
+                    33,
+                    7,
+                    29,
+                    37,
+                    40,
+                    29,
+                    71,
+                    75,
+                    5,
+                    63,
+                    16,
+                    29,
+                    34,
+                    16,
+                    61,
+                    96,
+                    17,
+                    76,
+                    76,
+                    19,
+                    69,
+                    70,
+                    61,
+                    14,
+                    29,
+                    10,
+                    37
+                ],
+                16
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    5,
+                    89,
+                    86,
+                    41,
+                    61,
+                    81,
+                    6,
+                    24,
+                    48,
+                    36,
+                    58,
+                    2,
+                    76,
+                    25,
+                    18,
+                    51,
+                    75,
+                    1,
+                    51,
+                    7,
+                    43,
+                    9,
+                    30,
+                    30,
+                    41,
+                    41,
+                    11,
+                    79
+                ],
+                49
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    76,
+                    86,
+                    22,
+                    69,
+                    47,
+                    36,
+                    46,
+                    12,
+                    56,
+                    6,
+                    77,
+                    30,
+                    77,
+                    36,
+                    65,
+                    10,
+                    32,
+                    48,
+                    62,
+                    75,
+                    58,
+                    65,
+                    39,
+                    3,
+                    9,
+                    21,
+                    24,
+                    68,
+                    93,
+                    6,
+                    34,
+                    80,
+                    84,
+                    5,
+                    4,
+                    70,
+                    5,
+                    46,
+                    30
+                ],
+                79
+            ],
+            "output": 7
+        },
+        {
+            "input": [
+                [
+                    7,
+                    49,
+                    35,
+                    59,
+                    41,
+                    43,
+                    27,
+                    60,
+                    13,
+                    47,
+                    39,
+                    16,
+                    56,
+                    74,
+                    76,
+                    87,
+                    17,
+                    61,
+                    30,
+                    9,
+                    99,
+                    99,
+                    42,
+                    25,
+                    18,
+                    95,
+                    56,
+                    86,
+                    41,
+                    87,
+                    53,
+                    87,
+                    32,
+                    25,
+                    87,
+                    62,
+                    58,
+                    60,
+                    71,
+                    74,
+                    16,
+                    67,
+                    76,
+                    85,
+                    78,
+                    23,
+                    10,
+                    4,
+                    96,
+                    96,
+                    57,
+                    46
+                ],
+                45
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                [
+                    50,
+                    2,
+                    70,
+                    95,
+                    9,
+                    66,
+                    2,
+                    82,
+                    95,
+                    84,
+                    33,
+                    65,
+                    44,
+                    66,
+                    83,
+                    17,
+                    1,
+                    29,
+                    92,
+                    8,
+                    96,
+                    100,
+                    6,
+                    74,
+                    96,
+                    71,
+                    78,
+                    73,
+                    53,
+                    9,
+                    45,
+                    79,
+                    90,
+                    57,
+                    72,
+                    49,
+                    87,
+                    79,
+                    80,
+                    67,
+                    50,
+                    68,
+                    89,
+                    15,
+                    89,
+                    39,
+                    45,
+                    51,
+                    52,
+                    59,
+                    21,
+                    12,
+                    87,
+                    74,
+                    52,
+                    30,
+                    47,
+                    23,
+                    23,
+                    56,
+                    62,
+                    13,
+                    16,
+                    51,
+                    96,
+                    64,
+                    18,
+                    12,
+                    71,
+                    22,
+                    39,
+                    95,
+                    48,
+                    4,
+                    39,
+                    42,
+                    78,
+                    59,
+                    11
+                ],
+                39
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    99,
+                    70,
+                    43,
+                    46,
+                    94,
+                    9,
+                    54,
+                    6,
+                    6,
+                    71,
+                    16,
+                    38,
+                    38,
+                    77,
+                    57,
+                    96,
+                    23,
+                    71,
+                    62,
+                    12,
+                    72,
+                    32,
+                    67,
+                    64,
+                    69,
+                    19,
+                    40,
+                    58,
+                    52,
+                    72,
+                    53,
+                    3,
+                    38,
+                    68,
+                    46,
+                    17,
+                    20,
+                    13,
+                    96,
+                    75,
+                    17,
+                    31,
+                    14,
+                    31,
+                    87,
+                    2,
+                    51,
+                    1,
+                    42,
+                    11
+                ],
+                45
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    68,
+                    67,
+                    25,
+                    41,
+                    20,
+                    45,
+                    71,
+                    46,
+                    84,
+                    36,
+                    50,
+                    98,
+                    4,
+                    59,
+                    55,
+                    32,
+                    80,
+                    33,
+                    37,
+                    4,
+                    71,
+                    26,
+                    77,
+                    26,
+                    100,
+                    52,
+                    41,
+                    47,
+                    46,
+                    39,
+                    43,
+                    93,
+                    15,
+                    18,
+                    58,
+                    38,
+                    6
+                ],
+                62
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    33,
+                    2,
+                    53,
+                    21,
+                    56,
+                    19,
+                    58,
+                    56,
+                    72,
+                    63,
+                    92,
+                    40,
+                    96,
+                    10,
+                    44,
+                    49,
+                    73,
+                    51,
+                    59,
+                    15,
+                    27,
+                    95,
+                    98,
+                    82,
+                    10,
+                    8,
+                    33,
+                    32,
+                    79,
+                    25,
+                    41,
+                    66,
+                    68,
+                    82,
+                    61,
+                    76,
+                    57,
+                    48,
+                    81,
+                    7,
+                    20,
+                    25,
+                    72,
+                    79,
+                    7,
+                    51,
+                    68,
+                    28,
+                    80,
+                    61,
+                    5,
+                    53,
+                    29,
+                    31,
+                    30,
+                    94,
+                    9,
+                    47,
+                    40,
+                    88,
+                    19,
+                    33,
+                    56,
+                    98,
+                    58,
+                    46,
+                    6,
+                    93,
+                    69,
+                    55,
+                    7,
+                    85,
+                    75,
+                    14,
+                    45,
+                    79,
+                    27,
+                    76,
+                    31,
+                    81,
+                    98,
+                    89,
+                    3,
+                    20,
+                    48,
+                    65,
+                    67,
+                    43,
+                    20,
+                    71,
+                    55,
+                    21,
+                    80,
+                    32,
+                    5,
+                    82
+                ],
+                99
+            ],
+            "output": 6
+        },
+        {
+            "input": [
+                [
+                    24,
+                    75,
+                    21,
+                    32,
+                    53,
+                    32,
+                    30,
+                    65,
+                    67,
+                    72,
+                    10,
+                    91,
+                    62,
+                    99,
+                    51,
+                    33,
+                    13,
+                    66,
+                    80,
+                    49,
+                    79,
+                    80,
+                    45,
+                    97,
+                    4,
+                    51,
+                    92,
+                    76,
+                    67,
+                    71,
+                    99,
+                    81,
+                    12,
+                    83,
+                    28,
+                    19,
+                    60,
+                    44,
+                    55,
+                    84,
+                    85,
+                    31,
+                    37,
+                    12,
+                    61,
+                    42,
+                    26,
+                    21,
+                    9,
+                    56,
+                    19,
+                    46,
+                    32,
+                    3,
+                    51,
+                    22,
+                    44,
+                    37,
+                    39,
+                    3,
+                    12,
+                    68,
+                    71,
+                    73,
+                    81,
+                    50,
+                    97,
+                    90,
+                    4,
+                    59,
+                    72,
+                    33,
+                    26,
+                    17,
+                    12,
+                    94,
+                    15,
+                    70,
+                    11,
+                    90,
+                    42,
+                    27,
+                    12,
+                    37,
+                    45,
+                    63,
+                    6
+                ],
+                16
+            ],
+            "output": 1
+        }
+    ],
+    "haskell_template": "longestAlternatingSubarray :: [Int] -> Int -> Int\nlongestAlternatingSubarray nums threshold ",
+    "ocaml_template": "let longestAlternatingSubarray (nums: int list) (threshold: int) : int =  ",
+    "scala_template": "def longestAlternatingSubarray(nums: List[Int],threshold: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int longestAlternatingSubarray(int[] nums, int threshold) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def longestAlternatingSubarray(self, nums, threshold):\n        \"\"\"\n        :type nums: List[int]\n        :type threshold: int\n        :rtype: int\n        \"\"\"\n        "
+}

longest_even_odd_subarray_with_threshold/ocaml_tests/main.ml

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

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

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

longest_ideal_subsequence/java_tests/Main.java

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

longest_ideal_subsequence/ocaml_tests/main.ml

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

longest_ideal_subsequence/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.longestIdealString("acfgbd",2), 4)
+  }
+
+  test("test2") {
+    assertEquals(Main.longestIdealString("abcd",3), 4)
+  }
+
+}

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

longest_increasing_subsequence_ii/java_tests/Main.java

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

longest_increasing_subsequence_ii/meta.json

@@ -0,0 +1,215 @@
+{
+    "id": 2526,
+    "name": "longest_increasing_subsequence_ii",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/longest-increasing-subsequence-ii/",
+    "date": "1662249600000",
+    "task_description": "You are given an integer array `nums` and an integer `k`. Find the longest subsequence of `nums` that meets the following requirements: The subsequence is **strictly increasing** and The difference between adjacent elements in the subsequence is **at most** `k`. Return_ the length of the **longest** **subsequence** that meets the requirements._ A **subsequence** is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements. **Example 1:** ``` **Input:** nums = [4,2,1,4,3,4,5,8,15], k = 3 **Output:** 5 **Explanation:** The longest subsequence that meets the requirements is [1,3,4,5,8]. The subsequence has a length of 5, so we return 5. Note that the subsequence [1,3,4,5,8,15] does not meet the requirements because 15 - 8 = 7 is larger than 3. ``` **Example 2:** ``` **Input:** nums = [7,4,5,1,8,12,4,7], k = 5 **Output:** 4 **Explanation:** The longest subsequence that meets the requirements is [4,5,8,12]. The subsequence has a length of 4, so we return 4. ``` **Example 3:** ``` **Input:** nums = [1,5], k = 1 **Output:** 1 **Explanation:** The longest subsequence that meets the requirements is [1]. The subsequence has a length of 1, so we return 1. ``` **Constraints:** `1 <= nums.length <= 105` `1 <= nums[i], k <= 105`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [4,2,1,4,3,4,5,8,15], k = 3",
+            "output": "5 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [7,4,5,1,8,12,4,7], k = 5",
+            "output": "4 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [1,5], k = 1",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    9,
+                    12,
+                    13,
+                    16,
+                    17,
+                    28,
+                    29,
+                    30,
+                    34,
+                    40,
+                    44,
+                    45,
+                    57,
+                    65
+                ],
+                97
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                [
+                    2,
+                    4,
+                    16,
+                    27,
+                    40,
+                    43,
+                    48,
+                    55,
+                    60,
+                    82,
+                    87,
+                    91,
+                    98,
+                    99
+                ],
+                75
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                [
+                    20,
+                    27,
+                    42,
+                    51,
+                    52,
+                    57,
+                    64,
+                    66,
+                    76,
+                    77,
+                    81,
+                    89,
+                    95,
+                    100
+                ],
+                45
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                [
+                    14,
+                    28,
+                    81
+                ],
+                96
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                [
+                    3,
+                    19,
+                    28,
+                    30,
+                    32,
+                    47,
+                    63,
+                    64,
+                    69,
+                    80,
+                    94,
+                    95
+                ],
+                33
+            ],
+            "output": 12
+        },
+        {
+            "input": [
+                [
+                    4,
+                    5,
+                    18,
+                    26,
+                    33,
+                    41,
+                    42,
+                    62,
+                    69,
+                    73,
+                    75,
+                    76,
+                    78,
+                    80,
+                    87,
+                    96,
+                    97,
+                    98,
+                    99
+                ],
+                39
+            ],
+            "output": 19
+        },
+        {
+            "input": [
+                [
+                    65,
+                    94
+                ],
+                18
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    64,
+                    95
+                ],
+                92
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    8,
+                    15,
+                    16,
+                    21,
+                    27,
+                    29,
+                    47,
+                    59,
+                    67,
+                    68,
+                    93,
+                    98
+                ],
+                5
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                [
+                    9,
+                    32,
+                    35,
+                    49,
+                    53,
+                    65,
+                    69,
+                    79,
+                    83,
+                    87,
+                    89
+                ],
+                86
+            ],
+            "output": 11
+        }
+    ],
+    "haskell_template": "lengthOfLIS :: [Int] -> Int -> Int\nlengthOfLIS nums k ",
+    "ocaml_template": "let lengthOfLIS (nums: int list) (k: int) : int =  ",
+    "scala_template": "def lengthOfLIS(nums: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "public static int lengthOfLIS(List<Integer> nums, int k) {\n\n}",
+    "python_template": "class Solution(object):\n    def lengthOfLIS(self, nums, k):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}