353c15902798457bfcfe773894f1f96829c77e28e06534d5893bcd1bf0591cb1

.gitattributes

@@ -71,3 +71,4 @@ check_if_grid_can_be_cut_into_sections/haskell_tests/Main.hs filter=lfs diff=lfs
 check_if_grid_can_be_cut_into_sections/meta.json filter=lfs diff=lfs merge=lfs -text
 check_if_grid_can_be_cut_into_sections/ocaml_tests/main.ml filter=lfs diff=lfs merge=lfs -text
 check_if_grid_can_be_cut_into_sections/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+closest_equal_element_queries/meta.json filter=lfs diff=lfs merge=lfs -text

check_if_strings_can_be_made_equal_with_operations_ii/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 (checkStrings \"abcdba \"  \"cabdab \")," True (checkStrings "abcdba" "cabdab"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (checkStrings \"abe \"  \"bea \")," False (checkStrings "abe" "bea"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

check_if_strings_can_be_made_equal_with_operations_ii/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(true, checkStrings("abcdba", "cabdab"));
+}
+@Test
+public void test2() {
+    assertEquals(false, checkStrings("abe", "bea"));
+}
+
+}

check_if_strings_can_be_made_equal_with_operations_ii/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (checkStrings "abcdba" "cabdab")
+
+let test2 _ = assert_equal false (checkStrings "abe" "bea")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for checkStrings" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

check_if_strings_can_be_made_equal_with_operations_ii/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.checkStrings("abcdba","cabdab"), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.checkStrings("abe","bea"), false)
+  }
+
+}

check_if_the_rectangle_corner_is_reachable/java_tests/Main.java

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

check_if_there_is_a_valid_parentheses_string_path/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 (hasValidPath [[ \"( \", \"( \", \"( \"],[ \") \", \"( \", \") \"],[ \"( \", \"( \", \") \"],[ \"( \", \"( \", \") \"]])," True (hasValidPath [["(","(","("],[")","(",")"],["(","(",")"],["(","(",")"]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (hasValidPath [[ \") \", \") \"],[ \"( \", \"( \"]])," False (hasValidPath [[")",")"],["(","("]]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

check_if_there_is_a_valid_parentheses_string_path/java_tests/Main.java

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

check_if_there_is_a_valid_parentheses_string_path/ocaml_tests/main.ml

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

check_if_there_is_a_valid_parentheses_string_path/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.hasValidPath(List(List("(","(","("),List(")","(",")"),List("(","(",")"),List("(","(",")"))), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.hasValidPath(List(List(")",")"),List("(","("))), false)
+  }
+
+}

check_if_there_is_a_valid_partition_for_the_array/haskell_tests/Main.hs

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

check_if_there_is_a_valid_partition_for_the_array/java_tests/Main.java

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

check_if_there_is_a_valid_partition_for_the_array/ocaml_tests/main.ml

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

check_if_there_is_a_valid_partition_for_the_array/scala_tests/MySuite.scala

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

check_if_two_chessboard_squares_have_the_same_color/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 (checkTwoChessboards \"a1 \"  \"c3 \")," True (checkTwoChessboards "a1" "c3"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (checkTwoChessboards \"a1 \"  \"h3 \")," False (checkTwoChessboards "a1" "h3"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (checkTwoChessboards  \"e4 \"  \"b5 \")," True (checkTwoChessboards "e4" "b5"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (checkTwoChessboards  \"c3 \"  \"c5 \")," True (checkTwoChessboards "c3" "c5"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (checkTwoChessboards  \"g8 \"  \"d6 \")," False (checkTwoChessboards "g8" "d6"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (checkTwoChessboards  \"e6 \"  \"a8 \")," True (checkTwoChessboards "e6" "a8"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (checkTwoChessboards  \"d6 \"  \"g7 \")," True (checkTwoChessboards "d6" "g7"))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (checkTwoChessboards  \"c8 \"  \"b5 \")," True (checkTwoChessboards "c8" "b5"))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (checkTwoChessboards  \"c4 \"  \"b3 \")," True (checkTwoChessboards "c4" "b3"))
+
+
+-- 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

check_if_two_chessboard_squares_have_the_same_color/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(true, checkTwoChessboards("a1", "c3"));
+}
+@Test
+public void test2() {
+    assertEquals(false, checkTwoChessboards("a1", "h3"));
+}
+
+}

check_if_two_chessboard_squares_have_the_same_color/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3553,
+    "name": "check_if_two_chessboard_squares_have_the_same_color",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/check-if-two-chessboard-squares-have-the-same-color/",
+    "date": "2024-08-25 00:00:00",
+    "task_description": "You are given two strings, `coordinate1` and `coordinate2`, representing the coordinates of a square on an `8 x 8` chessboard. Below is the chessboard for reference. Return `true` if these two squares have the same color and `false` otherwise. The coordinate will always represent a valid chessboard square. The coordinate will always have the letter first (indicating its column), and the number second (indicating its row). **Example 1:** **Input:** coordinate1 = \"a1\", coordinate2 = \"c3\" **Output:** true **Explanation:** Both squares are black. **Example 2:** **Input:** coordinate1 = \"a1\", coordinate2 = \"h3\" **Output:** false **Explanation:** Square `\"a1\"` is black and `\"h3\"` is white. **Constraints:** `coordinate1.length == coordinate2.length == 2` `'a' <= coordinate1[0], coordinate2[0] <= 'h'` `'1' <= coordinate1[1], coordinate2[1] <= '8'`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "coordinate1 = \"a1\", coordinate2 = \"c3\"",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "coordinate1 = \"a1\", coordinate2 = \"h3\"",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"e4\"",
+                "\"b5\""
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"c3\"",
+                "\"c5\""
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"g8\"",
+                "\"d6\""
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "\"e6\"",
+                "\"a8\""
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"d6\"",
+                "\"g7\""
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"c8\"",
+                "\"b5\""
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"c4\"",
+                "\"b3\""
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"c7\"",
+                "\"f3\""
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "c3",
+                "d3"
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "e6",
+                "a6"
+            ],
+            "output": true
+        }
+    ],
+    "haskell_template": "checkTwoChessboards :: String -> String -> Bool\ncheckTwoChessboards coordinate1 coordinate2 ",
+    "ocaml_template": "let checkTwoChessboards (coordinate1: string) (coordinate2: string) : bool =  ",
+    "scala_template": "def checkTwoChessboards(coordinate1: String,coordinate2: String): Boolean = { \n    \n}",
+    "java_template": "class Solution {\n    public boolean checkTwoChessboards(String coordinate1, String coordinate2) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def checkTwoChessboards(self, coordinate1, coordinate2):\n        \"\"\"\n        :type coordinate1: str\n        :type coordinate2: str\n        :rtype: bool\n        \"\"\"\n        "
+}

check_if_two_chessboard_squares_have_the_same_color/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (checkTwoChessboards "a1" "c3")
+
+let test2 _ = assert_equal false (checkTwoChessboards "a1" "h3")
+
+let test3 _ = assert_equal true (checkTwoChessboards "e4" "b5")
+
+let test4 _ = assert_equal true (checkTwoChessboards "c3" "c5")
+
+let test5 _ = assert_equal false (checkTwoChessboards "g8" "d6")
+
+let test6 _ = assert_equal true (checkTwoChessboards "e6" "a8")
+
+let test7 _ = assert_equal true (checkTwoChessboards "d6" "g7")
+
+let test8 _ = assert_equal true (checkTwoChessboards "c8" "b5")
+
+let test9 _ = assert_equal true (checkTwoChessboards "c4" "b3")
+
+let test10 _ = assert_equal false (checkTwoChessboards "c7" "f3")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for checkTwoChessboards" >::: [
+        
+  "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

check_if_two_chessboard_squares_have_the_same_color/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.checkTwoChessboards("a1","c3"), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.checkTwoChessboards("a1","h3"), false)
+  }
+
+  test("test3") {
+    assertEquals(Main.checkTwoChessboards("e4","b5"), true)
+  }
+
+  test("test4") {
+    assertEquals(Main.checkTwoChessboards("c3","c5"), true)
+  }
+
+  test("test5") {
+    assertEquals(Main.checkTwoChessboards("g8","d6"), false)
+  }
+
+  test("test6") {
+    assertEquals(Main.checkTwoChessboards("e6","a8"), true)
+  }
+
+  test("test7") {
+    assertEquals(Main.checkTwoChessboards("d6","g7"), true)
+  }
+
+  test("test8") {
+    assertEquals(Main.checkTwoChessboards("c8","b5"), true)
+  }
+
+  test("test9") {
+    assertEquals(Main.checkTwoChessboards("c4","b3"), true)
+  }
+
+  test("test10") {
+    assertEquals(Main.checkTwoChessboards("c7","f3"), false)
+  }
+
+}

circular_sentence/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 (isCircularSentence \"leetcode exercises sound delightful \")," True (isCircularSentence "leetcode exercises sound delightful"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (isCircularSentence \"eetcode \")," True (isCircularSentence "eetcode"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (isCircularSentence \"Leetcode is cool \")," False (isCircularSentence "Leetcode is cool"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

circular_sentence/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(true, isCircularSentence("leetcode exercises sound delightful"));
+}
+@Test
+public void test2() {
+    assertEquals(true, isCircularSentence("eetcode"));
+}
+@Test
+public void test3() {
+    assertEquals(false, isCircularSentence("Leetcode is cool"));
+}
+
+}

circular_sentence/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 2580,
+    "name": "circular_sentence",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/circular-sentence/",
+    "date": "1669507200000",
+    "task_description": "A **sentence** is a list of words that are separated by a** single** space with no leading or trailing spaces. For example, `\"Hello World\"`, `\"HELLO\"`, `\"hello world hello world\"` are all sentences. Words consist of **only** uppercase and lowercase English letters. Uppercase and lowercase English letters are considered different. A sentence is **circular **if: The last character of each word in the sentence is equal to the first character of its next word. The last character of the last word is equal to the first character of the first word. For example, `\"leetcode exercises sound delightful\"`, `\"eetcode\"`, `\"leetcode eats soul\" `are all circular sentences. However, `\"Leetcode is cool\"`, `\"happy Leetcode\"`, `\"Leetcode\"` and `\"I like Leetcode\"` are **not** circular sentences. Given a string `sentence`, return `true`_ if it is circular_. Otherwise, return `false`. **Example 1:** ``` **Input:** sentence = \"leetcode exercises sound delightful\" **Output:** true **Explanation:** The words in sentence are [\"leetcode\", \"exercises\", \"sound\", \"delightful\"]. - leetcode's last character is equal to exercises's first character. - exercises's last character is equal to sound's first character. - sound's last character is equal to delightful's first character. - delightful's last character is equal to leetcode's first character. The sentence is circular. ``` **Example 2:** ``` **Input:** sentence = \"eetcode\" **Output:** true **Explanation:** The words in sentence are [\"eetcode\"]. - eetcode's last character is equal to eetcode's first character. The sentence is circular. ``` **Example 3:** ``` **Input:** sentence = \"Leetcode is cool\" **Output:** false **Explanation:** The words in sentence are [\"Leetcode\", \"is\", \"cool\"]. - Leetcode's last character is **not** equal to is's first character. The sentence is **not** circular. ``` **Constraints:** `1 <= sentence.length <= 500` `sentence` consist of only lowercase and uppercase English letters and spaces. The words in `sentence` are separated by a single space. There are no leading or trailing spaces.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "sentence = \"leetcode exercises sound delightful\"",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "sentence = \"eetcode\"",
+            "output": "true "
+        },
+        {
+            "label": "Example 3",
+            "input": "sentence = \"Leetcode is cool\"",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "fcZnbHp pei iAoZbnqm mWDGGD Di iMXRcUGLK Kz zcRGYyAnBf f",
+            "output": true
+        },
+        {
+            "input": "D uaJqqD",
+            "output": false
+        },
+        {
+            "input": "N NrEM MkoAiuySGT TOiZfnD DCgIEUdRqU UE E EZSM MpUNnDcbqG rLKN",
+            "output": false
+        },
+        {
+            "input": "UBtlaUe eg gpOO OnbRcYOZN Nh hYxI IF FNKcF U",
+            "output": false
+        },
+        {
+            "input": "EzMT T TmQWKWYkHb LnAE",
+            "output": false
+        },
+        {
+            "input": "IqbYMzrYe ZtJvpaCsKI",
+            "output": false
+        },
+        {
+            "input": "OHl lGnrlCD DsaTqWr ruFmGmrZIL LpeRgq qHqB BsnpLsO OcyPtyuNMh YdDWaGhNO",
+            "output": false
+        },
+        {
+            "input": "hGcSvPns s sb bIle efi idzVBlgKC CZwfPL LxrdEKsP PQhv uh",
+            "output": false
+        },
+        {
+            "input": "BDdnaHx xhzXRF FFOLQDOY fxtlLB",
+            "output": false
+        },
+        {
+            "input": "STFrHQT Tgq qksvHxq qaKXv vwmLoyUT TsVq S",
+            "output": false
+        }
+    ],
+    "haskell_template": "isCircularSentence :: String -> Bool\nisCircularSentence sentence ",
+    "ocaml_template": "let isCircularSentence (sentence: string) : bool =  ",
+    "scala_template": "def isCircularSentence(sentence: String): Boolean = { \n    \n}",
+    "java_template": "public static boolean isCircularSentence(String sentence) {\n\n}",
+    "python_template": "class Solution(object):\n    def isCircularSentence(self, sentence):\n        \"\"\"\n        :type sentence: str\n        :rtype: bool\n        \"\"\"\n        "
+}

circular_sentence/ocaml_tests/main.ml

@@ -0,0 +1,29 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (isCircularSentence "leetcode exercises sound delightful")
+
+let test2 _ = assert_equal true (isCircularSentence "eetcode")
+
+let test3 _ = assert_equal false (isCircularSentence "Leetcode is cool")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for isCircularSentence" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

circular_sentence/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.isCircularSentence("leetcode exercises sound delightful"), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.isCircularSentence("eetcode"), true)
+  }
+
+  test("test3") {
+    assertEquals(Main.isCircularSentence("Leetcode is cool"), false)
+  }
+
+}

clear_digits/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+clearDigits :: String -> String
+clearDigits s = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (clearDigits \"abc \")," "abc" (clearDigits "abc"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (clearDigits \"cb34 \")," "" (clearDigits "cb34"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (clearDigits  \"zkjf6chmfz72qgdpdyzty389j8dh \")," "zkjchmqgdpdydh" (clearDigits "zkjf6chmfz72qgdpdyzty389j8dh"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (clearDigits  \"anar1l9tiiyl4pgt24zhc7qt7ixv4fetd9je34r5w8xsvb7yl7xvd78mayqqgy93jkwk5j2s2wwam7a0hkqsd \")," "anatiiypzhqixfetxsvyxmayqqjkwwwahkqsd" (clearDigits "anar1l9tiiyl4pgt24zhc7qt7ixv4fetd9je34r5w8xsvb7yl7xvd78mayqqgy93jkwk5j2s2wwam7a0hkqsd"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (clearDigits  \"ies3kufsimsq5x6ilfx1mf2u16f7hikc6lmf7cptlvd4bdv82x62rwm2 \")," "iekufsimsilfhiklmcptlvrw" (clearDigits "ies3kufsimsq5x6ilfx1mf2u16f7hikc6lmf7cptlvd4bdv82x62rwm2"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (clearDigits  \"5nq7mkio3abr9hx6y98dj965uhq55ehhen9f9xlgfnrkosl7i5xnse0ezbodlmjdsleucs \")," "mkiauehhexlgfnrkosxnsezbodlmjdsleucn" (clearDigits "5nq7mkio3abr9hx6y98dj965uhq55ehhen9f9xlgfnrkosl7i5xnse0ezbodlmjdsleucs"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (clearDigits  \"9j9mihoo9i0083t0ew7b2onsmd6zv974js4uuhvtca5taauie6f6mpllei3uuvstb9qnap7reomimrh7n03 \")," "eonsjuuhvtctaauimplleuuvstqnareomimrm" (clearDigits "9j9mihoo9i0083t0ew7b2onsmd6zv974js4uuhvtca5taauie6f6mpllei3uuvstb9qnap7reomimrh7n03"))
+
+
+-- 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

clear_digits/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("abc", clearDigits("abc"));
+}
+@Test
+public void test2() {
+    assertEquals("cb34", clearDigits("cb34"));
+}
+
+}

clear_digits/meta.json

@@ -0,0 +1,47 @@
+{
+    "id": 3447,
+    "name": "clear_digits",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/clear-digits/",
+    "date": "2024-05-25 00:00:00",
+    "task_description": "You are given a string `s`. Your task is to remove **all** digits by doing this operation repeatedly: Delete the _first_ digit and the **closest** non-digit character to its _left_. Return the resulting string after removing all digits. **Note** that the operation _cannot_ be performed on a digit that does not have any non-digit character to its left. **Example 1:** **Input:** s = \"abc\" **Output:** \"abc\" **Explanation:** There is no digit in the string. **Example 2:** **Input:** s = \"cb34\" **Output:** \"\" **Explanation:** First, we apply the operation on `s[2]`, and `s` becomes `\"c4\"`. Then we apply the operation on `s[1]`, and `s` becomes `\"\"`. **Constraints:** `1 <= s.length <= 100` `s` consists only of lowercase English letters and digits. The input is generated such that it is possible to delete all digits.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"abc\"",
+            "output": "\"abc\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"cb34\"",
+            "output": "\"\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "zkjf6chmfz72qgdpdyzty389j8dh",
+            "output": "zkjchmqgdpdydh"
+        },
+        {
+            "input": "anar1l9tiiyl4pgt24zhc7qt7ixv4fetd9je34r5w8xsvb7yl7xvd78mayqqgy93jkwk5j2s2wwam7a0hkqsd",
+            "output": "anatiiypzhqixfetxsvyxmayqqjkwwwahkqsd"
+        },
+        {
+            "input": "ies3kufsimsq5x6ilfx1mf2u16f7hikc6lmf7cptlvd4bdv82x62rwm2",
+            "output": "iekufsimsilfhiklmcptlvrw"
+        },
+        {
+            "input": "5nq7mkio3abr9hx6y98dj965uhq55ehhen9f9xlgfnrkosl7i5xnse0ezbodlmjdsleucs",
+            "output": "mkiauehhexlgfnrkosxnsezbodlmjdsleucn"
+        },
+        {
+            "input": "9j9mihoo9i0083t0ew7b2onsmd6zv974js4uuhvtca5taauie6f6mpllei3uuvstb9qnap7reomimrh7n03",
+            "output": "eonsjuuhvtctaauimplleuuvstqnareomimrm"
+        }
+    ],
+    "haskell_template": "clearDigits :: String -> String\nclearDigits s ",
+    "ocaml_template": "let clearDigits (s: string) : string =  ",
+    "scala_template": "def clearDigits(s: String): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String clearDigits(String s) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def clearDigits(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: str\n        \"\"\"\n        "
+}

clear_digits/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let clearDigits (s: string) : string =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "abc" (clearDigits "abc")
+
+let test2 _ = assert_equal "" (clearDigits "cb34")
+
+let test3 _ = assert_equal "" (clearDigits "zkjf6chmfz72qgdpdyzty389j8dh")
+
+let test4 _ = assert_equal "" (clearDigits "anar1l9tiiyl4pgt24zhc7qt7ixv4fetd9je34r5w8xsvb7yl7xvd78mayqqgy93jkwk5j2s2wwam7a0hkqsd")
+
+let test5 _ = assert_equal "" (clearDigits "ies3kufsimsq5x6ilfx1mf2u16f7hikc6lmf7cptlvd4bdv82x62rwm2")
+
+let test6 _ = assert_equal "" (clearDigits "5nq7mkio3abr9hx6y98dj965uhq55ehhen9f9xlgfnrkosl7i5xnse0ezbodlmjdsleucs")
+
+let test7 _ = assert_equal "" (clearDigits "9j9mihoo9i0083t0ew7b2onsmd6zv974js4uuhvtca5taauie6f6mpllei3uuvstb9qnap7reomimrh7n03")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for clearDigits" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

clear_digits/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.clearDigits("abc"), "abc")
+  }
+
+  test("test2") {
+    assertEquals(Main.clearDigits("cb34"), "")
+  }
+
+  test("test3") {
+    assertEquals(Main.clearDigits(",z,k,j,f,6,c,h,m,f,z,7,2,q,g,d,p,d,y,z,t,y,3,8,9,j,8,d,h,"), "zkjchmqgdpdydh")
+  }
+
+  test("test4") {
+    assertEquals(Main.clearDigits(",a,n,a,r,1,l,9,t,i,i,y,l,4,p,g,t,2,4,z,h,c,7,q,t,7,i,x,v,4,f,e,t,d,9,j,e,3,4,r,5,w,8,x,s,v,b,7,y,l,7,x,v,d,7,8,m,a,y,q,q,g,y,9,3,j,k,w,k,5,j,2,s,2,w,w,a,m,7,a,0,h,k,q,s,d,"), "anatiiypzhqixfetxsvyxmayqqjkwwwahkqsd")
+  }
+
+  test("test5") {
+    assertEquals(Main.clearDigits(",i,e,s,3,k,u,f,s,i,m,s,q,5,x,6,i,l,f,x,1,m,f,2,u,1,6,f,7,h,i,k,c,6,l,m,f,7,c,p,t,l,v,d,4,b,d,v,8,2,x,6,2,r,w,m,2,"), "iekufsimsilfhiklmcptlvrw")
+  }
+
+  test("test6") {
+    assertEquals(Main.clearDigits(",5,n,q,7,m,k,i,o,3,a,b,r,9,h,x,6,y,9,8,d,j,9,6,5,u,h,q,5,5,e,h,h,e,n,9,f,9,x,l,g,f,n,r,k,o,s,l,7,i,5,x,n,s,e,0,e,z,b,o,d,l,m,j,d,s,l,e,u,c,s,"), "mkiauehhexlgfnrkosxnsezbodlmjdsleucn")
+  }
+
+  test("test7") {
+    assertEquals(Main.clearDigits(",9,j,9,m,i,h,o,o,9,i,0,0,8,3,t,0,e,w,7,b,2,o,n,s,m,d,6,z,v,9,7,4,j,s,4,u,u,h,v,t,c,a,5,t,a,a,u,i,e,6,f,6,m,p,l,l,e,i,3,u,u,v,s,t,b,9,q,n,a,p,7,r,e,o,m,i,m,r,h,7,n,0,3,"), "eonsjuuhvtctaauimplleuuvstqnareomimrm")
+  }
+
+}

closest_equal_element_queries/java_tests/Main.java

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

closest_equal_element_queries/meta.json

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

closest_prime_numbers_in_range/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 (closestPrimes 10 19)," [11,13] (closestPrimes 10 19))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (closestPrimes 4 6)," [-1,-1] (closestPrimes 4 6))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

closest_prime_numbers_in_range/java_tests/Main.java

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

closest_prime_numbers_in_range/meta.json

@@ -0,0 +1,127 @@
+{
+    "id": 2610,
+    "name": "closest_prime_numbers_in_range",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/closest-prime-numbers-in-range/",
+    "date": "1671926400000",
+    "task_description": "Given two positive integers `left` and `right`, find the two integers `num1` and `num2` such that: `left <= num1 < num2 <= right `. Both `num1` and `num2` are prime numbers. `num2 - num1` is the **minimum** amongst all other pairs satisfying the above conditions. Return the positive integer array `ans = [num1, num2]`. If there are multiple pairs satisfying these conditions, return the one with the **smallest** `num1` value. If no such numbers exist, return `[-1, -1]`_._ **Example 1:** ``` **Input:** left = 10, right = 19 **Output:** [11,13] **Explanation:** The prime numbers between 10 and 19 are 11, 13, 17, and 19. The closest gap between any pair is 2, which can be achieved by [11,13] or [17,19]. Since 11 is smaller than 17, we return the first pair. ``` **Example 2:** ``` **Input:** left = 4, right = 6 **Output:** [-1,-1] **Explanation:** There exists only one prime number in the given range, so the conditions cannot be satisfied. ``` **Constraints:** `1 <= left <= right <= 106`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "left = 10, right = 19",
+            "output": "[11,13] "
+        },
+        {
+            "label": "Example 2",
+            "input": "left = 4, right = 6",
+            "output": "[-1,-1] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                259000,
+                604761
+            ],
+            "output": [
+                259121,
+                259123
+            ]
+        },
+        {
+            "input": [
+                957158,
+                972359
+            ],
+            "output": [
+                957431,
+                957433
+            ]
+        },
+        {
+            "input": [
+                55246,
+                763571
+            ],
+            "output": [
+                55331,
+                55333
+            ]
+        },
+        {
+            "input": [
+                649910,
+                686398
+            ],
+            "output": [
+                650327,
+                650329
+            ]
+        },
+        {
+            "input": [
+                331636,
+                938904
+            ],
+            "output": [
+                331691,
+                331693
+            ]
+        },
+        {
+            "input": [
+                725612,
+                912608
+            ],
+            "output": [
+                725861,
+                725863
+            ]
+        },
+        {
+            "input": [
+                124471,
+                281197
+            ],
+            "output": [
+                124541,
+                124543
+            ]
+        },
+        {
+            "input": [
+                523427,
+                663663
+            ],
+            "output": [
+                523487,
+                523489
+            ]
+        },
+        {
+            "input": [
+                863522,
+                999759
+            ],
+            "output": [
+                863537,
+                863539
+            ]
+        },
+        {
+            "input": [
+                508948,
+                963261
+            ],
+            "output": [
+                509147,
+                509149
+            ]
+        }
+    ],
+    "haskell_template": "closestPrimes :: Int -> Int -> [Int]\nclosestPrimes left right ",
+    "ocaml_template": "let closestPrimes (left: int) (right: int) : int list =  ",
+    "scala_template": "def closestPrimes(left: Int,right: Int): List[Int] = { \n    \n}",
+    "java_template": "public static List<Integer> closestPrimes(int left, int right) {\n\n}",
+    "python_template": "class Solution(object):\n    def closestPrimes(self, left, right):\n        \"\"\"\n        :type left: int\n        :type right: int\n        :rtype: List[int]\n        \"\"\"\n        "
+}

closest_prime_numbers_in_range/ocaml_tests/main.ml

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