01f8c30643da4e616b39828bdd070cc9851cf24934ec52fcd98787d2c1446c33

buy_two_chocolates/scala_tests/MySuite.scala

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

calculate_delayed_arrival_time/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 (findDelayedArrivalTime 15 5)," 20 (findDelayedArrivalTime 15 5))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findDelayedArrivalTime 13 11)," 0 (findDelayedArrivalTime 13 11))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

calculate_delayed_arrival_time/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(20, findDelayedArrivalTime(15, 5));
+}
+@Test
+public void test2() {
+    assertEquals(0, findDelayedArrivalTime(13, 11));
+}
+
+}

calculate_delayed_arrival_time/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 2748,
+    "name": "calculate_delayed_arrival_time",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/calculate-delayed-arrival-time/",
+    "date": "1681603200000",
+    "task_description": "You are given a positive integer `arrivalTime` denoting the arrival time of a train in hours, and another positive integer `delayedTime` denoting the amount of delay in hours. Return _the time when the train will arrive at the station._ Note that the time in this problem is in 24-hours format. **Example 1:** ``` **Input:** arrivalTime = 15, delayedTime = 5 **Output:** 20 **Explanation:** Arrival time of the train was 15:00 hours. It is delayed by 5 hours. Now it will reach at 15+5 = 20 (20:00 hours). ``` **Example 2:** ``` **Input:** arrivalTime = 13, delayedTime = 11 **Output:** 0 **Explanation:** Arrival time of the train was 13:00 hours. It is delayed by 11 hours. Now it will reach at 13+11=24 (Which is denoted by 00:00 in 24 hours format so return 0). ``` **Constraints:** `1 <= arrivaltime < 24` `1 <= delayedTime <= 24`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "arrivalTime = 15, delayedTime = 5",
+            "output": "20 "
+        },
+        {
+            "label": "Example 2",
+            "input": "arrivalTime = 13, delayedTime = 11",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                18,
+                19
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                10,
+                12
+            ],
+            "output": 22
+        },
+        {
+            "input": [
+                9,
+                23
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                6,
+                3
+            ],
+            "output": 9
+        },
+        {
+            "input": [
+                3,
+                21
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                5,
+                13
+            ],
+            "output": 18
+        },
+        {
+            "input": [
+                11,
+                1
+            ],
+            "output": 12
+        },
+        {
+            "input": [
+                13,
+                11
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                5,
+                2
+            ],
+            "output": 7
+        },
+        {
+            "input": [
+                12,
+                5
+            ],
+            "output": 17
+        }
+    ],
+    "haskell_template": "findDelayedArrivalTime :: Int -> Int -> Int\nfindDelayedArrivalTime arrivalTime delayedTime ",
+    "ocaml_template": "let findDelayedArrivalTime (arrivalTime: int) (delayedTime: int) : int =  ",
+    "scala_template": "def findDelayedArrivalTime(arrivalTime: Int,delayedTime: Int): Int = { \n    \n}",
+    "java_template": "public static int findDelayedArrivalTime(int arrivalTime, int delayedTime) {\n\n}",
+    "python_template": "class Solution(object):\n    def findDelayedArrivalTime(self, arrivalTime, delayedTime):\n        \"\"\"\n        :type arrivalTime: int\n        :type delayedTime: int\n        :rtype: int\n        \"\"\"\n        "
+}

calculate_delayed_arrival_time/ocaml_tests/main.ml

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

calculate_delayed_arrival_time/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findDelayedArrivalTime(15,5), 20)
+  }
+
+  test("test2") {
+    assertEquals(Main.findDelayedArrivalTime(13,11), 0)
+  }
+
+}

calculate_digit_sum_of_a_string/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (digitSum \"11111222223 \" 3)," "135" (digitSum "11111222223" 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (digitSum \"00000000 \" 3)," "000" (digitSum "00000000" 3))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (digitSum  \"0 \" 2)," "0" (digitSum "0" 2))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (digitSum  \"6421145198777362190042394610980120758216614468524308044135603727111584866360410865574469873746173533 \" 2)," "59" (digitSum "6421145198777362190042394610980120758216614468524308044135603727111584866360410865574469873746173533" 2))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (digitSum  \"6828549665923521139586766197204369524222360091033439842730341293447277906510091763414462467630345859 \" 100)," "6828549665923521139586766197204369524222360091033439842730341293447277906510091763414462467630345859" (digitSum "6828549665923521139586766197204369524222360091033439842730341293447277906510091763414462467630345859" 100))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (digitSum  \"86835675433222437140367269363341651026820150582311446699662136 \" 12)," "60414742559" (digitSum "86835675433222437140367269363341651026820150582311446699662136" 12))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (digitSum  \"09556959624863822113055328888211114768861024488160715110957533476207255541787 \" 52)," "228109" (digitSum "09556959624863822113055328888211114768861024488160715110957533476207255541787" 52))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (digitSum  \"33628763334261975447998353546830413109540456 \" 40)," "18315" (digitSum "33628763334261975447998353546830413109540456" 40))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (digitSum  \"4261628821970427731371304870116953 \" 26)," "10632" (digitSum "4261628821970427731371304870116953" 26))
+
+
+-- 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

calculate_digit_sum_of_a_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("3", digitSum("11111222223", 3));
+}
+@Test
+public void test2() {
+    assertEquals("3", digitSum("00000000", 3));
+}
+
+}

calculate_digit_sum_of_a_string/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 2361,
+    "name": "calculate_digit_sum_of_a_string",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/calculate-digit-sum-of-a-string/",
+    "date": "2022-04-10 00:00:00",
+    "task_description": "You are given a string `s` consisting of digits and an integer `k`. A **round** can be completed if the length of `s` is greater than `k`. In one round, do the following: **Divide** `s` into **consecutive groups** of size `k` such that the first `k` characters are in the first group, the next `k` characters are in the second group, and so on. **Note** that the size of the last group can be smaller than `k`. **Replace** each group of `s` with a string representing the sum of all its digits. For example, `\"346\"` is replaced with `\"13\"` because `3 + 4 + 6 = 13`. **Merge** consecutive groups together to form a new string. If the length of the string is greater than `k`, repeat from step `1`. Return `s` _after all rounds have been completed_. **Example 1:** ``` **Input:** s = \"11111222223\", k = 3 **Output:** \"135\" **Explanation:** - For the first round, we divide s into groups of size 3: \"111\", \"112\", \"222\", and \"23\". ​​​​​Then we calculate the digit sum of each group: 1 + 1 + 1 = 3, 1 + 1 + 2 = 4, 2 + 2 + 2 = 6, and 2 + 3 = 5. So, s becomes \"3\" + \"4\" + \"6\" + \"5\" = \"3465\" after the first round. - For the second round, we divide s into \"346\" and \"5\". Then we calculate the digit sum of each group: 3 + 4 + 6 = 13, 5 = 5. So, s becomes \"13\" + \"5\" = \"135\" after second round. Now, s.length <= k, so we return \"135\" as the answer. ``` **Example 2:** ``` **Input:** s = \"00000000\", k = 3 **Output:** \"000\" **Explanation:** We divide s into \"000\", \"000\", and \"00\". Then we calculate the digit sum of each group: 0 + 0 + 0 = 0, 0 + 0 + 0 = 0, and 0 + 0 = 0. s becomes \"0\" + \"0\" + \"0\" = \"000\", whose length is equal to k, so we return \"000\". ``` **Constraints:** `1 <= s.length <= 100` `2 <= k <= 100` `s` consists of digits only.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"11111222223\", k = 3",
+            "output": "\"135\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"00000000\", k = 3",
+            "output": "\"000\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"0\"",
+                2
+            ],
+            "output": "0"
+        },
+        {
+            "input": [
+                "\"6421145198777362190042394610980120758216614468524308044135603727111584866360410865574469873746173533\"",
+                2
+            ],
+            "output": "59"
+        },
+        {
+            "input": [
+                "\"6828549665923521139586766197204369524222360091033439842730341293447277906510091763414462467630345859\"",
+                100
+            ],
+            "output": "6828549665923521139586766197204369524222360091033439842730341293447277906510091763414462467630345859"
+        },
+        {
+            "input": [
+                "\"86835675433222437140367269363341651026820150582311446699662136\"",
+                12
+            ],
+            "output": "60414742559"
+        },
+        {
+            "input": [
+                "\"09556959624863822113055328888211114768861024488160715110957533476207255541787\"",
+                52
+            ],
+            "output": "228109"
+        },
+        {
+            "input": [
+                "\"33628763334261975447998353546830413109540456\"",
+                40
+            ],
+            "output": "18315"
+        },
+        {
+            "input": [
+                "\"4261628821970427731371304870116953\"",
+                26
+            ],
+            "output": "10632"
+        },
+        {
+            "input": [
+                "\"6260198388\"",
+                7
+            ],
+            "output": "3219"
+        },
+        {
+            "input": [
+                "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+                30
+            ],
+            "output": "000"
+        },
+        {
+            "input": [
+                "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999",
+                100
+            ],
+            "output": "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+        }
+    ],
+    "haskell_template": "digitSum :: String -> Int -> String\ndigitSum s k ",
+    "ocaml_template": "let digitSum (s: string) (k: int) : string =  ",
+    "scala_template": "def digitSum(s: String,k: Int): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String digitSum(String s, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def digitSum(self, s, k):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :rtype: str\n        \"\"\"\n        "
+}

calculate_digit_sum_of_a_string/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "135" (digitSum "11111222223" 3)
+
+let test2 _ = assert_equal "000" (digitSum "00000000" 3)
+
+let test3 _ = assert_equal "0" (digitSum "0" 2)
+
+let test4 _ = assert_equal "59" (digitSum "6421145198777362190042394610980120758216614468524308044135603727111584866360410865574469873746173533" 2)
+
+let test5 _ = assert_equal "6828549665923521139586766197204369524222360091033439842730341293447277906510091763414462467630345859" (digitSum "6828549665923521139586766197204369524222360091033439842730341293447277906510091763414462467630345859" 100)
+
+let test6 _ = assert_equal "60414742559" (digitSum "86835675433222437140367269363341651026820150582311446699662136" 12)
+
+let test7 _ = assert_equal "228109" (digitSum "09556959624863822113055328888211114768861024488160715110957533476207255541787" 52)
+
+let test8 _ = assert_equal "18315" (digitSum "33628763334261975447998353546830413109540456" 40)
+
+let test9 _ = assert_equal "10632" (digitSum "4261628821970427731371304870116953" 26)
+
+let test10 _ = assert_equal "3219" (digitSum "6260198388" 7)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for digitSum" >::: [
+        
+  "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

calculate_digit_sum_of_a_string/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.digitSum("11111222223",3), "135")
+  }
+
+  test("test2") {
+    assertEquals(Main.digitSum("00000000",3), "000")
+  }
+
+  test("test3") {
+    assertEquals(Main.digitSum("0",2), "0")
+  }
+
+  test("test4") {
+    assertEquals(Main.digitSum("6421145198777362190042394610980120758216614468524308044135603727111584866360410865574469873746173533",2), "59")
+  }
+
+  test("test5") {
+    assertEquals(Main.digitSum("6828549665923521139586766197204369524222360091033439842730341293447277906510091763414462467630345859",100), "6828549665923521139586766197204369524222360091033439842730341293447277906510091763414462467630345859")
+  }
+
+  test("test6") {
+    assertEquals(Main.digitSum("86835675433222437140367269363341651026820150582311446699662136",12), "60414742559")
+  }
+
+  test("test7") {
+    assertEquals(Main.digitSum("09556959624863822113055328888211114768861024488160715110957533476207255541787",52), "228109")
+  }
+
+  test("test8") {
+    assertEquals(Main.digitSum("33628763334261975447998353546830413109540456",40), "18315")
+  }
+
+  test("test9") {
+    assertEquals(Main.digitSum("4261628821970427731371304870116953",26), "10632")
+  }
+
+  test("test10") {
+    assertEquals(Main.digitSum("6260198388",7), "3219")
+  }
+
+}

categorize_box_according_to_criteria/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 (categorizeBox 1000 35 700 300)," "Heavy" (categorizeBox 1000 35 700 300))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (categorizeBox 200 50 800 50)," "Neither" (categorizeBox 200 50 800 50))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (categorizeBox 73 46 67 57)," "Neither" (categorizeBox 73 46 67 57))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (categorizeBox 50 82 13 85)," "Neither" (categorizeBox 50 82 13 85))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (categorizeBox 46 40 34 60)," "Neither" (categorizeBox 46 40 34 60))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (categorizeBox 43 11 66 39)," "Neither" (categorizeBox 43 11 66 39))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (categorizeBox 87 4 22 50)," "Neither" (categorizeBox 87 4 22 50))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (categorizeBox 59 91 54 65)," "Neither" (categorizeBox 59 91 54 65))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (categorizeBox 59 22 102 48)," "Neither" (categorizeBox 59 22 102 48))
+
+
+-- 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

categorize_box_according_to_criteria/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("300", categorizeBox(1000, 35, 700, 300));
+}
+@Test
+public void test2() {
+    assertEquals("50", categorizeBox(200, 50, 800, 50));
+}
+
+}

categorize_box_according_to_criteria/meta.json

@@ -0,0 +1,117 @@
+{
+    "id": 2619,
+    "name": "categorize_box_according_to_criteria",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/categorize-box-according-to-criteria/",
+    "date": "2022-12-24 00:00:00",
+    "task_description": "Given four integers `length`, `width`, `height`, and `mass`, representing the dimensions and mass of a box, respectively, return _a string representing the **category** of the box_. The box is `\"Bulky\"` if: **Any** of the dimensions of the box is greater or equal to `104`. Or, the **volume** of the box is greater or equal to `109`. If the mass of the box is greater or equal to `100`, it is `\"Heavy\".` If the box is both `\"Bulky\"` and `\"Heavy\"`, then its category is `\"Both\"`. If the box is neither `\"Bulky\"` nor `\"Heavy\"`, then its category is `\"Neither\"`. If the box is `\"Bulky\"` but not `\"Heavy\"`, then its category is `\"Bulky\"`. If the box is `\"Heavy\"` but not `\"Bulky\"`, then its category is `\"Heavy\"`. **Note** that the volume of the box is the product of its length, width and height. **Example 1:** ``` **Input:** length = 1000, width = 35, height = 700, mass = 300 **Output:** \"Heavy\" **Explanation:** None of the dimensions of the box is greater or equal to 104. Its volume = 24500000 <= 109. So it cannot be categorized as \"Bulky\". However mass >= 100, so the box is \"Heavy\". Since the box is not \"Bulky\" but \"Heavy\", we return \"Heavy\". ``` **Example 2:** ``` **Input:** length = 200, width = 50, height = 800, mass = 50 **Output:** \"Neither\" **Explanation:** None of the dimensions of the box is greater or equal to 104. Its volume = 8 * 106 <= 109. So it cannot be categorized as \"Bulky\". Its mass is also less than 100, so it cannot be categorized as \"Heavy\" either. Since its neither of the two above categories, we return \"Neither\". ``` **Constraints:** `1 <= length, width, height <= 105` `1 <= mass <= 103`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "length = 1000, width = 35, height = 700, mass = 300",
+            "output": "\"Heavy\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "length = 200, width = 50, height = 800, mass = 50",
+            "output": "\"Neither\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                73,
+                46,
+                67,
+                57
+            ],
+            "output": "Neither"
+        },
+        {
+            "input": [
+                50,
+                82,
+                13,
+                85
+            ],
+            "output": "Neither"
+        },
+        {
+            "input": [
+                46,
+                40,
+                34,
+                60
+            ],
+            "output": "Neither"
+        },
+        {
+            "input": [
+                43,
+                11,
+                66,
+                39
+            ],
+            "output": "Neither"
+        },
+        {
+            "input": [
+                87,
+                4,
+                22,
+                50
+            ],
+            "output": "Neither"
+        },
+        {
+            "input": [
+                59,
+                91,
+                54,
+                65
+            ],
+            "output": "Neither"
+        },
+        {
+            "input": [
+                59,
+                22,
+                102,
+                48
+            ],
+            "output": "Neither"
+        },
+        {
+            "input": [
+                93,
+                5,
+                88,
+                56
+            ],
+            "output": "Neither"
+        },
+        {
+            "input": [
+                95,
+                9,
+                22,
+                99
+            ],
+            "output": "Neither"
+        },
+        {
+            "input": [
+                104,
+                78,
+                28,
+                8
+            ],
+            "output": "Neither"
+        }
+    ],
+    "haskell_template": "categorizeBox :: Int -> Int -> Int -> Int -> String\ncategorizeBox length width height mass ",
+    "ocaml_template": "let categorizeBox (length: int) (width: int) (height: int) (mass: int) : string =  ",
+    "scala_template": "def categorizeBox(length: Int,width: Int,height: Int,mass: Int): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String categorizeBox(int length, int width, int height, int mass) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def categorizeBox(self, length, width, height, mass):\n        \"\"\"\n        :type length: int\n        :type width: int\n        :type height: int\n        :type mass: int\n        :rtype: str\n        \"\"\"\n        "
+}

categorize_box_according_to_criteria/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "Heavy" (categorizeBox 1000 35 700 300)
+
+let test2 _ = assert_equal "Neither" (categorizeBox 200 50 800 50)
+
+let test3 _ = assert_equal "Neither" (categorizeBox 73 46 67 57)
+
+let test4 _ = assert_equal "Neither" (categorizeBox 50 82 13 85)
+
+let test5 _ = assert_equal "Neither" (categorizeBox 46 40 34 60)
+
+let test6 _ = assert_equal "Neither" (categorizeBox 43 11 66 39)
+
+let test7 _ = assert_equal "Neither" (categorizeBox 87 4 22 50)
+
+let test8 _ = assert_equal "Neither" (categorizeBox 59 91 54 65)
+
+let test9 _ = assert_equal "Neither" (categorizeBox 59 22 102 48)
+
+let test10 _ = assert_equal "Neither" (categorizeBox 93 5 88 56)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for categorizeBox" >::: [
+        
+  "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

categorize_box_according_to_criteria/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.categorizeBox(1000,35,700,300), "Heavy")
+  }
+
+  test("test2") {
+    assertEquals(Main.categorizeBox(200,50,800,50), "Neither")
+  }
+
+  test("test3") {
+    assertEquals(Main.categorizeBox(73,46,67,57), "Neither")
+  }
+
+  test("test4") {
+    assertEquals(Main.categorizeBox(50,82,13,85), "Neither")
+  }
+
+  test("test5") {
+    assertEquals(Main.categorizeBox(46,40,34,60), "Neither")
+  }
+
+  test("test6") {
+    assertEquals(Main.categorizeBox(43,11,66,39), "Neither")
+  }
+
+  test("test7") {
+    assertEquals(Main.categorizeBox(87,4,22,50), "Neither")
+  }
+
+  test("test8") {
+    assertEquals(Main.categorizeBox(59,91,54,65), "Neither")
+  }
+
+  test("test9") {
+    assertEquals(Main.categorizeBox(59,22,102,48), "Neither")
+  }
+
+  test("test10") {
+    assertEquals(Main.categorizeBox(93,5,88,56), "Neither")
+  }
+
+}

cells_in_a_range_on_an_excel_sheet/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 (cellsInRange \"K1:L2 \")," ["K1","K2","L1","L2"] (cellsInRange "K1:L2"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (cellsInRange \"A1:F1 \")," ["A1","B1","C1","D1","E1","F1"] (cellsInRange "A1:F1"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

cells_in_a_range_on_an_excel_sheet/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("K1","K2","L1","L2")), cellsInRange("K1:L2"));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList("A1","B1","C1","D1","E1","F1")), cellsInRange("A1:F1"));
+}
+
+}

cells_in_a_range_on_an_excel_sheet/meta.json

@@ -0,0 +1,201 @@
+{
+    "id": 2304,
+    "name": "cells_in_a_range_on_an_excel_sheet",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/cells-in-a-range-on-an-excel-sheet/",
+    "date": "1645920000000",
+    "task_description": "A cell `(r, c)` of an excel sheet is represented as a string `\"<col><row>\"` where: `<col>` denotes the column number `c` of the cell. It is represented by **alphabetical letters**. For example, the `1st` column is denoted by `'A'`, the `2nd` by `'B'`, the `3rd` by `'C'`, and so on. `<row>` is the row number `r` of the cell. The `rth` row is represented by the **integer** `r`. You are given a string `s` in the format `\"<col1><row1>:<col2><row2>\"`, where `<col1>` represents the column `c1`, `<row1>` represents the row `r1`, `<col2>` represents the column `c2`, and `<row2>` represents the row `r2`, such that `r1 <= r2` and `c1 <= c2`. Return _the **list of cells**_ `(x, y)` _such that_ `r1 <= x <= r2` _and_ `c1 <= y <= c2`. The cells should be represented as **strings** in the format mentioned above and be sorted in **non-decreasing** order first by columns and then by rows. **Example 1:** ``` **Input:** s = \"K1:L2\" **Output:** [\"K1\",\"K2\",\"L1\",\"L2\"] **Explanation:** The above diagram shows the cells which should be present in the list. The red arrows denote the order in which the cells should be presented. ``` **Example 2:** ``` **Input:** s = \"A1:F1\" **Output:** [\"A1\",\"B1\",\"C1\",\"D1\",\"E1\",\"F1\"] **Explanation:** The above diagram shows the cells which should be present in the list. The red arrow denotes the order in which the cells should be presented. ``` **Constraints:** `s.length == 5` `'A' <= s[0] <= s[3] <= 'Z'` `'1' <= s[1] <= s[4] <= '9'` `s` consists of uppercase English letters, digits and `':'`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"K1:L2\"",
+            "output": "[\"K1\",\"K2\",\"L1\",\"L2\"] "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"A1:F1\"",
+            "output": "[\"A1\",\"B1\",\"C1\",\"D1\",\"E1\",\"F1\"] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "\"C8:D8\"",
+            "output": [
+                "C8",
+                "D8"
+            ]
+        },
+        {
+            "input": "\"S9:V9\"",
+            "output": [
+                "S9",
+                "T9",
+                "U9",
+                "V9"
+            ]
+        },
+        {
+            "input": "\"Y6:Y9\"",
+            "output": [
+                "Y6",
+                "Y7",
+                "Y8",
+                "Y9"
+            ]
+        },
+        {
+            "input": "\"U9:W9\"",
+            "output": [
+                "U9",
+                "V9",
+                "W9"
+            ]
+        },
+        {
+            "input": "\"H2:O7\"",
+            "output": [
+                "H2",
+                "H3",
+                "H4",
+                "H5",
+                "H6",
+                "H7",
+                "I2",
+                "I3",
+                "I4",
+                "I5",
+                "I6",
+                "I7",
+                "J2",
+                "J3",
+                "J4",
+                "J5",
+                "J6",
+                "J7",
+                "K2",
+                "K3",
+                "K4",
+                "K5",
+                "K6",
+                "K7",
+                "L2",
+                "L3",
+                "L4",
+                "L5",
+                "L6",
+                "L7",
+                "M2",
+                "M3",
+                "M4",
+                "M5",
+                "M6",
+                "M7",
+                "N2",
+                "N3",
+                "N4",
+                "N5",
+                "N6",
+                "N7",
+                "O2",
+                "O3",
+                "O4",
+                "O5",
+                "O6",
+                "O7"
+            ]
+        },
+        {
+            "input": "\"N6:O8\"",
+            "output": [
+                "N6",
+                "N7",
+                "N8",
+                "O6",
+                "O7",
+                "O8"
+            ]
+        },
+        {
+            "input": "\"Q1:S8\"",
+            "output": [
+                "Q1",
+                "Q2",
+                "Q3",
+                "Q4",
+                "Q5",
+                "Q6",
+                "Q7",
+                "Q8",
+                "R1",
+                "R2",
+                "R3",
+                "R4",
+                "R5",
+                "R6",
+                "R7",
+                "R8",
+                "S1",
+                "S2",
+                "S3",
+                "S4",
+                "S5",
+                "S6",
+                "S7",
+                "S8"
+            ]
+        },
+        {
+            "input": "K9:T9",
+            "output": [
+                "K9",
+                "L9",
+                "M9",
+                "N9",
+                "O9",
+                "P9",
+                "Q9",
+                "R9",
+                "S9",
+                "T9"
+            ]
+        },
+        {
+            "input": "W6:W8",
+            "output": [
+                "W6",
+                "W7",
+                "W8"
+            ]
+        },
+        {
+            "input": "O5:S8",
+            "output": [
+                "O5",
+                "O6",
+                "O7",
+                "O8",
+                "P5",
+                "P6",
+                "P7",
+                "P8",
+                "Q5",
+                "Q6",
+                "Q7",
+                "Q8",
+                "R5",
+                "R6",
+                "R7",
+                "R8",
+                "S5",
+                "S6",
+                "S7",
+                "S8"
+            ]
+        }
+    ],
+    "haskell_template": "cellsInRange :: String -> [String]\ncellsInRange s ",
+    "ocaml_template": "let cellsInRange (s: string) : string list =  ",
+    "scala_template": "def cellsInRange(s: String): List[String] = { \n    \n}",
+    "java_template": "public static List<String> cellsInRange(String s) {\n\n}",
+    "python_template": "class Solution(object):\n    def cellsInRange(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: List[str]\n        \"\"\"\n        "
+}

cells_in_a_range_on_an_excel_sheet/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal ["K1";"K2";"L1";"L2"] (cellsInRange "K1:L2")
+
+let test2 _ = assert_equal ["A1";"B1";"C1";"D1";"E1";"F1"] (cellsInRange "A1:F1")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for cellsInRange" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

cells_in_a_range_on_an_excel_sheet/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.cellsInRange("K1:L2"), List("K1","K2","L1","L2"))
+  }
+
+  test("test2") {
+    assertEquals(Main.cellsInRange("A1:F1"), List("A1","B1","C1","D1","E1","F1"))
+  }
+
+}

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

check_distances_between_same_letters/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, checkDistances("abaccb", new ArrayList<>(Arrays.asList(1,3,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0))));
+}
+@Test
+public void test2() {
+    assertEquals(false, checkDistances("aa", new ArrayList<>(Arrays.asList(1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0))));
+}
+
+}

check_distances_between_same_letters/meta.json

@@ -0,0 +1,367 @@
+{
+    "id": 2476,
+    "name": "check_distances_between_same_letters",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/check-distances-between-same-letters/",
+    "date": "1661644800000",
+    "task_description": "You are given a **0-indexed** string `s` consisting of only lowercase English letters, where each letter in `s` appears **exactly** **twice**. You are also given a **0-indexed** integer array `distance` of length `26`. Each letter in the alphabet is numbered from `0` to `25` (i.e. `'a' -> 0`, `'b' -> 1`, `'c' -> 2`, ... , `'z' -> 25`). In a **well-spaced** string, the number of letters between the two occurrences of the `ith` letter is `distance[i]`. If the `ith` letter does not appear in `s`, then `distance[i]` can be **ignored**. Return `true`_ if _`s`_ is a **well-spaced** string, otherwise return _`false`. **Example 1:** ``` **Input:** s = \"abaccb\", distance = [1,3,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] **Output:** true **Explanation:** - 'a' appears at indices 0 and 2 so it satisfies distance[0] = 1. - 'b' appears at indices 1 and 5 so it satisfies distance[1] = 3. - 'c' appears at indices 3 and 4 so it satisfies distance[2] = 0. Note that distance[3] = 5, but since 'd' does not appear in s, it can be ignored. Return true because s is a well-spaced string. ``` **Example 2:** ``` **Input:** s = \"aa\", distance = [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] **Output:** false **Explanation:** - 'a' appears at indices 0 and 1 so there are zero letters between them. Because distance[0] = 1, s is not a well-spaced string. ``` **Constraints:** `2 <= s.length <= 52` `s` consists only of lowercase English letters. Each letter appears in `s` exactly twice. `distance.length == 26` `0 <= distance[i] <= 50`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"abaccb\", distance = [1,3,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"aa\", distance = [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"ppqkargjvtumhlvtqagumlrkjh\"",
+                [
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0
+                ]
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"sbkoxnxabigccaljjeiosgknel\"",
+                [
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    -1,
+                    0,
+                    0
+                ]
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"agymhjaxnjxvnveiyefhgfccmi\"",
+                [
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    0
+                ]
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"blbkmlimqnuddeqjjfefknisus\"",
+                [
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0
+                ]
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"dwdnqujjmrzcquprwcipznttim\"",
+                [
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    0,
+                    -1
+                ]
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"gcbgmcpfqvmqlvbottzaplzofa\"",
+                [
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    -1
+                ]
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"nocmzrbdbtmekkfofdzncrtlle\"",
+                [
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    -1
+                ]
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "gdqcfafcbtivuruibvytqyrgda",
+                [
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    0
+                ]
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "pjgwlwmedffnalaykngkjpymed",
+                [
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    0
+                ]
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "ddvfvcyizunfpiypuslcrrlnzs",
+                [
+                    0,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    -1,
+                    -1,
+                    0,
+                    0,
+                    -1,
+                    -1
+                ]
+            ],
+            "output": true
+        }
+    ],
+    "haskell_template": "checkDistances :: String -> [Int] -> Bool\ncheckDistances s distance ",
+    "ocaml_template": "let checkDistances (s: string) (distance: int list) : bool =  ",
+    "scala_template": "def checkDistances(s: String,distance: List[Int]): Boolean = { \n    \n}",
+    "java_template": "public static boolean checkDistances(String s, List<Integer> distance) {\n\n}",
+    "python_template": "class Solution(object):\n    def checkDistances(self, s, distance):\n        \"\"\"\n        :type s: str\n        :type distance: List[int]\n        :rtype: bool\n        \"\"\"\n        "
+}

check_distances_between_same_letters/ocaml_tests/main.ml

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

check_distances_between_same_letters/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.checkDistances("abaccb",[1,3,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.checkDistances("aa",[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]), false)
+  }
+
+}

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

check_if_all_as_appears_before_all_bs/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, checkString("aaabbb"));
+}
+@Test
+public void test2() {
+    assertEquals(false, checkString("abab"));
+}
+@Test
+public void test3() {
+    assertEquals(true, checkString("bbb"));
+}
+
+}

check_if_all_as_appears_before_all_bs/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 2243,
+    "name": "check_if_all_as_appears_before_all_bs",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/check-if-all-as-appears-before-all-bs/",
+    "date": "1640476800000",
+    "task_description": "Given a string `s` consisting of **only** the characters `'a'` and `'b'`, return `true` _if **every** _`'a'` _appears before **every** _`'b'`_ in the string_. Otherwise, return `false`. **Example 1:** ``` **Input:** s = \"aaabbb\" **Output:** true **Explanation:** The 'a's are at indices 0, 1, and 2, while the 'b's are at indices 3, 4, and 5. Hence, every 'a' appears before every 'b' and we return true. ``` **Example 2:** ``` **Input:** s = \"abab\" **Output:** false **Explanation:** There is an 'a' at index 2 and a 'b' at index 1. Hence, not every 'a' appears before every 'b' and we return false. ``` **Example 3:** ``` **Input:** s = \"bbb\" **Output:** true **Explanation:** There are no 'a's, hence, every 'a' appears before every 'b' and we return true. ``` **Constraints:** `1 <= s.length <= 100` `s[i]` is either `'a'` or `'b'`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"aaabbb\"",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"abab\"",
+            "output": "false "
+        },
+        {
+            "label": "Example 3",
+            "input": "s = \"bbb\"",
+            "output": "true "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "ababbbbaabaababbbabbbb",
+            "output": false
+        },
+        {
+            "input": "aaaabbaabbaabab",
+            "output": false
+        },
+        {
+            "input": "aaabbabbbbabaabbbbababaabaababba",
+            "output": false
+        },
+        {
+            "input": "abbabbbbaaabbaabbbaabbbbbbabbaaaba",
+            "output": false
+        },
+        {
+            "input": "babababaaaabbbbaaaaabbbabbabbbabaaaaaababbbbaabbababbbbbbbaabbbaabbaaabbbbaabbbaaaabab",
+            "output": false
+        },
+        {
+            "input": "babaab",
+            "output": false
+        },
+        {
+            "input": "ababaaabbbaabbabaaaaabbaaaabbababaabaaaaaaabaaaabbaabaaaabbabbb",
+            "output": false
+        },
+        {
+            "input": "baababababbaabbabbbbbbabbbaababbbaabbbaaaabaabbbabbabbbabababbbabbbabaab",
+            "output": false
+        },
+        {
+            "input": "abb",
+            "output": true
+        },
+        {
+            "input": "abbabaabbbb",
+            "output": false
+        }
+    ],
+    "haskell_template": "checkString :: String -> Bool\ncheckString s ",
+    "ocaml_template": "let checkString (s: string) : bool =  ",
+    "scala_template": "def checkString(s: String): Boolean = { \n    \n}",
+    "java_template": "public static boolean checkString(String s) {\n\n}",
+    "python_template": "class Solution(object):\n    def checkString(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: bool\n        \"\"\"\n        "
+}

check_if_all_as_appears_before_all_bs/ocaml_tests/main.ml

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

check_if_all_as_appears_before_all_bs/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.checkString("aaabbb"), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.checkString("abab"), false)
+  }
+
+  test("test3") {
+    assertEquals(Main.checkString("bbb"), true)
+  }
+
+}

check_if_array_is_good/haskell_tests/Main.hs

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

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

check_if_array_is_good/meta.json

@@ -0,0 +1,577 @@
+{
+    "id": 2892,
+    "name": "check_if_array_is_good",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/check-if-array-is-good/",
+    "date": "1688774400000",
+    "task_description": "You are given an integer array `nums`. We consider an array **good **if it is a permutation of an array `base[n]`. `base[n] = [1, 2, ..., n - 1, n, n] `(in other words, it is an array of length `n + 1` which contains `1` to `n - 1 `exactly once, plus two occurrences of `n`). For example, `base[1] = [1, 1]` and` base[3] = [1, 2, 3, 3]`. Return `true` _if the given array is good, otherwise return__ _`false`. **Note: **A permutation of integers represents an arrangement of these numbers. **Example 1:** ``` **Input:** nums = [2, 1, 3] **Output:** false **Explanation:** Since the maximum element of the array is 3, the only candidate n for which this array could be a permutation of base[n], is n = 3. However, base[3] has four elements but array nums has three. Therefore, it can not be a permutation of base[3] = [1, 2, 3, 3]. So the answer is false. ``` **Example 2:** ``` **Input:** nums = [1, 3, 3, 2] **Output:** true **Explanation:** Since the maximum element of the array is 3, the only candidate n for which this array could be a permutation of base[n], is n = 3. It can be seen that nums is a permutation of base[3] = [1, 2, 3, 3] (by swapping the second and fourth elements in nums, we reach base[3]). Therefore, the answer is true. ``` **Example 3:** ``` **Input:** nums = [1, 1] **Output:** true **Explanation:** Since the maximum element of the array is 1, the only candidate n for which this array could be a permutation of base[n], is n = 1. It can be seen that nums is a permutation of base[1] = [1, 1]. Therefore, the answer is true. ``` **Example 4:** ``` **Input:** nums = [3, 4, 4, 1, 2, 1] **Output:** false **Explanation:** Since the maximum element of the array is 4, the only candidate n for which this array could be a permutation of base[n], is n = 4. However, base[4] has five elements but array nums has six. Therefore, it can not be a permutation of base[4] = [1, 2, 3, 4, 4]. So the answer is false. ``` **Constraints:** `1 <= nums.length <= 100` `1 <= num[i] <= 200`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2, 1, 3]",
+            "output": "false "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1, 3, 3, 2]",
+            "output": "true "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [1, 1]",
+            "output": "true "
+        },
+        {
+            "label": "Example 4",
+            "input": "nums = [3, 4, 4, 1, 2, 1]",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                43,
+                16,
+                46,
+                25,
+                29,
+                12,
+                23,
+                27,
+                9,
+                36,
+                8,
+                11,
+                52,
+                17,
+                3,
+                50,
+                35,
+                51,
+                31,
+                20,
+                33,
+                22,
+                26,
+                37,
+                21,
+                34,
+                47,
+                41,
+                28,
+                18,
+                15,
+                2,
+                44,
+                4,
+                6,
+                10,
+                39,
+                19,
+                40,
+                32,
+                30,
+                1,
+                24,
+                7,
+                13,
+                48,
+                5,
+                49,
+                14,
+                38,
+                45,
+                42
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                5,
+                1,
+                2,
+                4,
+                3
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                12,
+                8,
+                5,
+                4,
+                19,
+                16,
+                7,
+                9,
+                13,
+                11,
+                10,
+                14,
+                17,
+                3,
+                2,
+                18,
+                15,
+                6,
+                1
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                24,
+                1,
+                31,
+                32,
+                16,
+                37,
+                3,
+                81,
+                50,
+                52,
+                4,
+                55,
+                69,
+                80,
+                41,
+                45,
+                42,
+                60,
+                59,
+                19,
+                18,
+                40,
+                7,
+                61,
+                8,
+                34,
+                22,
+                20,
+                75,
+                48,
+                77,
+                72,
+                76,
+                78,
+                63,
+                25,
+                15,
+                65,
+                35,
+                53,
+                39,
+                11,
+                57,
+                5,
+                58,
+                47,
+                26,
+                62,
+                10,
+                28,
+                29,
+                14,
+                71,
+                33,
+                82,
+                83,
+                44,
+                66,
+                79,
+                17,
+                38,
+                68,
+                23,
+                6,
+                30,
+                54,
+                64,
+                2,
+                43,
+                67,
+                36,
+                74,
+                21,
+                13,
+                70,
+                9,
+                51,
+                49,
+                27,
+                46,
+                12,
+                73,
+                56
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                2,
+                85,
+                84,
+                18,
+                65,
+                63,
+                23,
+                19,
+                81,
+                5,
+                49,
+                60,
+                26,
+                9,
+                7,
+                61,
+                39,
+                62,
+                35,
+                4,
+                21,
+                76,
+                44,
+                73,
+                54,
+                69,
+                47,
+                11,
+                59,
+                55,
+                89,
+                80,
+                50,
+                83,
+                33,
+                57,
+                25,
+                3,
+                68,
+                75,
+                64,
+                16,
+                22,
+                42,
+                1,
+                29,
+                17,
+                31,
+                37,
+                40,
+                45,
+                51,
+                13,
+                43,
+                86,
+                30,
+                52,
+                41,
+                82,
+                10,
+                53,
+                14,
+                38,
+                15,
+                32,
+                28,
+                72,
+                77,
+                56,
+                58,
+                34,
+                79,
+                70,
+                90,
+                88,
+                24,
+                87,
+                48,
+                20,
+                12,
+                66,
+                78,
+                27,
+                91,
+                71,
+                6,
+                8,
+                67,
+                36,
+                74,
+                46
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                33,
+                92,
+                94,
+                81,
+                22,
+                60,
+                23,
+                88,
+                29,
+                31,
+                1,
+                42,
+                83,
+                9,
+                16,
+                21,
+                19,
+                51,
+                86,
+                52,
+                17,
+                57,
+                43,
+                18,
+                67,
+                46,
+                13,
+                54,
+                89,
+                69,
+                11,
+                27,
+                28,
+                85,
+                50,
+                30,
+                80,
+                56,
+                34,
+                79,
+                55,
+                72,
+                36,
+                62,
+                87,
+                84,
+                49,
+                58,
+                90,
+                47,
+                75,
+                66,
+                7,
+                14,
+                71,
+                40,
+                93,
+                77,
+                70,
+                38,
+                32,
+                61,
+                24,
+                39,
+                45,
+                44,
+                48,
+                68,
+                5,
+                65,
+                76,
+                10,
+                35,
+                6,
+                78,
+                95,
+                41,
+                3,
+                64,
+                73,
+                91,
+                20,
+                15,
+                82,
+                74,
+                37,
+                63,
+                2,
+                12,
+                8,
+                26,
+                59,
+                25,
+                4,
+                53
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                7,
+                13,
+                24,
+                22,
+                15,
+                4,
+                25,
+                6,
+                20,
+                9,
+                17,
+                3,
+                12,
+                18,
+                21,
+                14,
+                1,
+                2,
+                8,
+                5,
+                16,
+                19,
+                10,
+                23,
+                11,
+                25
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                12,
+                3,
+                4,
+                8,
+                16,
+                17,
+                2,
+                9,
+                13,
+                7,
+                18,
+                1,
+                11,
+                14,
+                5,
+                10,
+                6,
+                15
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                1,
+                5,
+                17,
+                10,
+                9,
+                11,
+                14,
+                20,
+                3,
+                18,
+                6,
+                7,
+                12,
+                19,
+                15,
+                13,
+                4,
+                2,
+                8,
+                16
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                6,
+                67,
+                70,
+                21,
+                75,
+                53,
+                48,
+                16,
+                77,
+                66,
+                74,
+                26,
+                38,
+                30,
+                4,
+                32,
+                56,
+                63,
+                55,
+                81,
+                44,
+                46,
+                54,
+                60,
+                72,
+                57,
+                65,
+                19,
+                37,
+                52,
+                27,
+                50,
+                78,
+                59,
+                39,
+                8,
+                12,
+                13,
+                58,
+                20,
+                68,
+                10,
+                76,
+                49,
+                34,
+                79,
+                9,
+                71,
+                14,
+                28,
+                42,
+                45,
+                61,
+                5,
+                31,
+                29,
+                36,
+                7,
+                41,
+                24,
+                3,
+                15,
+                17,
+                2,
+                40,
+                22,
+                33,
+                80,
+                25,
+                73,
+                18,
+                64,
+                51,
+                11,
+                69,
+                47,
+                23,
+                35,
+                43,
+                1,
+                62
+            ],
+            "output": false
+        }
+    ],
+    "haskell_template": "isGood :: [Int] -> Bool\nisGood nums ",
+    "ocaml_template": "let isGood (nums: int list) : bool =  ",
+    "scala_template": "def isGood(nums: List[Int]): Boolean = { \n    \n}",
+    "java_template": "public static boolean isGood(List<Integer> nums) {\n\n}",
+    "python_template": "class Solution(object):\n    def isGood(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: bool\n        \"\"\"\n        "
+}

check_if_array_is_good/ocaml_tests/main.ml

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

check_if_array_is_good/scala_tests/MySuite.scala

@@ -0,0 +1,20 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.isGood(List(2, 1, 3)), false)
+  }
+
+  test("test2") {
+    assertEquals(Main.isGood(List(1, 3, 3, 2)), true)
+  }
+
+  test("test3") {
+    assertEquals(Main.isGood(List(1, 1)), true)
+  }
+
+  test("test4") {
+    assertEquals(Main.isGood(List(3, 4, 4, 1, 2, 1)), false)
+  }
+
+}

check_if_bitwise_or_has_trailing_zeros/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+hasTrailingZeros :: [Int] -> Bool
+hasTrailingZeros nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (hasTrailingZeros [1,2,3,4,5])," True (hasTrailingZeros [1,2,3,4,5]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (hasTrailingZeros [2,4,8,16])," True (hasTrailingZeros [2,4,8,16]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (hasTrailingZeros [1,3,5,7,9])," False (hasTrailingZeros [1,3,5,7,9]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (hasTrailingZeros [38, 96, 54, 93, 34, 65, 95, 25, 63, 49, 32, 96, 5, 46, 95, 16, 53, 25, 1, 84, 18, 3, 91, 20, 63, 11, 71, 63, 63, 2, 98, 68])," True (hasTrailingZeros [38, 96, 54, 93, 34, 65, 95, 25, 63, 49, 32, 96, 5, 46, 95, 16, 53, 25, 1, 84, 18, 3, 91, 20, 63, 11, 71, 63, 63, 2, 98, 68]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (hasTrailingZeros [17, 64, 92, 91, 94, 66, 87, 91, 18, 44, 65, 37, 41, 16, 38, 74, 91, 37, 38, 36, 9, 4, 7, 75, 3])," True (hasTrailingZeros [17, 64, 92, 91, 94, 66, 87, 91, 18, 44, 65, 37, 41, 16, 38, 74, 91, 37, 38, 36, 9, 4, 7, 75, 3]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (hasTrailingZeros [73, 56, 23, 72, 18, 92, 82, 54, 87, 3, 1, 77, 70, 15, 24, 72, 47, 27, 82, 11, 87, 21, 47, 75, 53, 3, 21, 4, 84, 64, 4, 36, 52, 40, 80, 86, 25, 74, 1, 2, 90, 35, 5, 82, 45, 59, 78, 1, 56, 16, 63, 69, 86, 65, 62, 8, 54, 92, 35])," True (hasTrailingZeros [73, 56, 23, 72, 18, 92, 82, 54, 87, 3, 1, 77, 70, 15, 24, 72, 47, 27, 82, 11, 87, 21, 47, 75, 53, 3, 21, 4, 84, 64, 4, 36, 52, 40, 80, 86, 25, 74, 1, 2, 90, 35, 5, 82, 45, 59, 78, 1, 56, 16, 63, 69, 86, 65, 62, 8, 54, 92, 35]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (hasTrailingZeros [26, 41, 28, 25, 23, 11, 71, 31, 38, 23, 58, 87, 51, 80, 73, 53, 69, 94, 65, 73, 92, 96, 82, 89, 33, 51, 68, 16, 73, 92, 7, 13, 25, 35, 42, 34, 3, 45, 84, 73, 47, 60, 83, 16, 94, 85, 90, 19, 58, 32, 29, 2, 19, 90, 80, 60, 21, 64, 21, 50, 27, 8, 71, 59, 19, 55, 13, 31, 92, 36, 90, 44, 29, 88])," True (hasTrailingZeros [26, 41, 28, 25, 23, 11, 71, 31, 38, 23, 58, 87, 51, 80, 73, 53, 69, 94, 65, 73, 92, 96, 82, 89, 33, 51, 68, 16, 73, 92, 7, 13, 25, 35, 42, 34, 3, 45, 84, 73, 47, 60, 83, 16, 94, 85, 90, 19, 58, 32, 29, 2, 19, 90, 80, 60, 21, 64, 21, 50, 27, 8, 71, 59, 19, 55, 13, 31, 92, 36, 90, 44, 29, 88]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (hasTrailingZeros [3, 80, 72, 87, 40, 47, 92, 43, 47, 27, 51, 14, 23])," True (hasTrailingZeros [3, 80, 72, 87, 40, 47, 92, 43, 47, 27, 51, 14, 23]))
+
+
+-- 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

check_if_bitwise_or_has_trailing_zeros/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(true, hasTrailingZeros(Arrays.asList(1,2,3,4,5)));
+}
+@Test
+public void test2() {
+    assertEquals(true, hasTrailingZeros(Arrays.asList(2,4,8,16)));
+}
+@Test
+public void test3() {
+    assertEquals(false, hasTrailingZeros(Arrays.asList(1,3,5,7,9)));
+}
+
+}

check_if_bitwise_or_has_trailing_zeros/meta.json

@@ -0,0 +1,260 @@
+{
+    "id": 3246,
+    "name": "check_if_bitwise_or_has_trailing_zeros",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/check-if-bitwise-or-has-trailing-zeros/",
+    "date": "2023-12-24 00:00:00",
+    "task_description": "You are given an array of **positive** integers `nums`. You have to check if it is possible to select **two or more** elements in the array such that the bitwise `OR` of the selected elements has **at least **one trailing zero in its binary representation. For example, the binary representation of `5`, which is `\"101\"`, does not have any trailing zeros, whereas the binary representation of `4`, which is `\"100\"`, has two trailing zeros. Return `true` _if it is possible to select two or more elements whose bitwise_ `OR` _has trailing zeros, return_ `false` _otherwise_. **Example 1:** ``` **Input:** nums = [1,2,3,4,5] **Output:** true **Explanation:** If we select the elements 2 and 4, their bitwise OR is 6, which has the binary representation \"110\" with one trailing zero. ``` **Example 2:** ``` **Input:** nums = [2,4,8,16] **Output:** true **Explanation: **If we select the elements 2 and 4, their bitwise OR is 6, which has the binary representation \"110\" with one trailing zero. Other possible ways to select elements to have trailing zeroes in the binary representation of their bitwise OR are: (2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), and (2, 4, 8, 16). ``` **Example 3:** ``` **Input:** nums = [1,3,5,7,9] **Output:** false **Explanation:** There is no possible way to select two or more elements to have trailing zeros in the binary representation of their bitwise OR. ``` **Constraints:** `2 <= nums.length <= 100` `1 <= nums[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3,4,5]",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,4,8,16]",
+            "output": "true "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [1,3,5,7,9]",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                38,
+                96,
+                54,
+                93,
+                34,
+                65,
+                95,
+                25,
+                63,
+                49,
+                32,
+                96,
+                5,
+                46,
+                95,
+                16,
+                53,
+                25,
+                1,
+                84,
+                18,
+                3,
+                91,
+                20,
+                63,
+                11,
+                71,
+                63,
+                63,
+                2,
+                98,
+                68
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                17,
+                64,
+                92,
+                91,
+                94,
+                66,
+                87,
+                91,
+                18,
+                44,
+                65,
+                37,
+                41,
+                16,
+                38,
+                74,
+                91,
+                37,
+                38,
+                36,
+                9,
+                4,
+                7,
+                75,
+                3
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                73,
+                56,
+                23,
+                72,
+                18,
+                92,
+                82,
+                54,
+                87,
+                3,
+                1,
+                77,
+                70,
+                15,
+                24,
+                72,
+                47,
+                27,
+                82,
+                11,
+                87,
+                21,
+                47,
+                75,
+                53,
+                3,
+                21,
+                4,
+                84,
+                64,
+                4,
+                36,
+                52,
+                40,
+                80,
+                86,
+                25,
+                74,
+                1,
+                2,
+                90,
+                35,
+                5,
+                82,
+                45,
+                59,
+                78,
+                1,
+                56,
+                16,
+                63,
+                69,
+                86,
+                65,
+                62,
+                8,
+                54,
+                92,
+                35
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                26,
+                41,
+                28,
+                25,
+                23,
+                11,
+                71,
+                31,
+                38,
+                23,
+                58,
+                87,
+                51,
+                80,
+                73,
+                53,
+                69,
+                94,
+                65,
+                73,
+                92,
+                96,
+                82,
+                89,
+                33,
+                51,
+                68,
+                16,
+                73,
+                92,
+                7,
+                13,
+                25,
+                35,
+                42,
+                34,
+                3,
+                45,
+                84,
+                73,
+                47,
+                60,
+                83,
+                16,
+                94,
+                85,
+                90,
+                19,
+                58,
+                32,
+                29,
+                2,
+                19,
+                90,
+                80,
+                60,
+                21,
+                64,
+                21,
+                50,
+                27,
+                8,
+                71,
+                59,
+                19,
+                55,
+                13,
+                31,
+                92,
+                36,
+                90,
+                44,
+                29,
+                88
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                3,
+                80,
+                72,
+                87,
+                40,
+                47,
+                92,
+                43,
+                47,
+                27,
+                51,
+                14,
+                23
+            ],
+            "output": true
+        }
+    ],
+    "haskell_template": "hasTrailingZeros :: [Int] -> Bool\nhasTrailingZeros nums ",
+    "ocaml_template": "let hasTrailingZeros (nums: int list) : bool =  ",
+    "scala_template": "def hasTrailingZeros(nums: List[Int]): Boolean = { \n    \n}",
+    "java_template": "class Solution {\n    public boolean hasTrailingZeros(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def hasTrailingZeros(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: bool\n        \"\"\"\n        "
+}

check_if_bitwise_or_has_trailing_zeros/ocaml_tests/main.ml

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

check_if_bitwise_or_has_trailing_zeros/scala_tests/MySuite.scala

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

check_if_dfs_strings_are_palindromes/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(true,true,false,true,true,true)), findAnswer(new ArrayList<>(Arrays.asList(-1,0,0,1,1,2)), "aababa"));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(true,true,true,true,true)), findAnswer(new ArrayList<>(Arrays.asList(-1,0,0,0,0)), "aabcb"));
+}
+
+}

check_if_digits_are_equal_in_string_after_operations_i/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+hasSameDigits :: String -> Bool
+hasSameDigits s = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (hasSameDigits \"3902 \")," True (hasSameDigits "3902"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (hasSameDigits \"34789 \")," False (hasSameDigits "34789"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (hasSameDigits  \"080106026594954500183678394943283033982 \")," False (hasSameDigits "080106026594954500183678394943283033982"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (hasSameDigits  \"00486228987769246002704187817143095792028728199148076753 \")," False (hasSameDigits "00486228987769246002704187817143095792028728199148076753"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (hasSameDigits  \"3570365 \")," False (hasSameDigits "3570365"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (hasSameDigits  \"92620400561677676252552905 \")," False (hasSameDigits "92620400561677676252552905"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (hasSameDigits  \"875309239615263366778154628481005783992597976749683081112195313738052054049604554683400901666054 \")," False (hasSameDigits "875309239615263366778154628481005783992597976749683081112195313738052054049604554683400901666054"))
+
+
+-- 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

check_if_digits_are_equal_in_string_after_operations_i/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(true, hasSameDigits("3902"));
+}
+@Test
+public void test2() {
+    assertEquals(false, hasSameDigits("34789"));
+}
+
+}

check_if_digits_are_equal_in_string_after_operations_i/meta.json

@@ -0,0 +1,47 @@
+{
+    "id": 3768,
+    "name": "check_if_digits_are_equal_in_string_after_operations_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/check-if-digits-are-equal-in-string-after-operations-i/",
+    "date": "2025-02-16 00:00:00",
+    "task_description": "You are given a string `s` consisting of digits. Perform the following operation repeatedly until the string has **exactly** two digits: For each pair of consecutive digits in `s`, starting from the first digit, calculate a new digit as the sum of the two digits **modulo** 10. Replace `s` with the sequence of newly calculated digits, _maintaining the order_ in which they are computed. Return `true` if the final two digits in `s` are the **same**; otherwise, return `false`. **Example 1:** **Input:** s = \"3902\" **Output:** true **Explanation:** Initially, `s = \"3902\"` First operation: `(s[0] + s[1]) % 10 = (3 + 9) % 10 = 2` `(s[1] + s[2]) % 10 = (9 + 0) % 10 = 9` `(s[2] + s[3]) % 10 = (0 + 2) % 10 = 2` `s` becomes `\"292\"` Second operation: `(s[0] + s[1]) % 10 = (2 + 9) % 10 = 1` `(s[1] + s[2]) % 10 = (9 + 2) % 10 = 1` `s` becomes `\"11\"` Since the digits in `\"11\"` are the same, the output is `true`. **Example 2:** **Input:** s = \"34789\" **Output:** false **Explanation:** Initially, `s = \"34789\"`. After the first operation, `s = \"7157\"`. After the second operation, `s = \"862\"`. After the third operation, `s = \"48\"`. Since `'4' != '8'`, the output is `false`. **Constraints:** `3 <= s.length <= 100` `s` consists of only digits.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"3902\"",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"34789\"",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "080106026594954500183678394943283033982",
+            "output": false
+        },
+        {
+            "input": "00486228987769246002704187817143095792028728199148076753",
+            "output": false
+        },
+        {
+            "input": "3570365",
+            "output": false
+        },
+        {
+            "input": "92620400561677676252552905",
+            "output": false
+        },
+        {
+            "input": "875309239615263366778154628481005783992597976749683081112195313738052054049604554683400901666054",
+            "output": false
+        }
+    ],
+    "haskell_template": "hasSameDigits :: String -> Bool\nhasSameDigits s ",
+    "ocaml_template": "let hasSameDigits (s: string) : bool =  ",
+    "scala_template": "def hasSameDigits(s: String): Boolean = { \n    \n}",
+    "java_template": "class Solution {\n    public boolean hasSameDigits(String s) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def hasSameDigits(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: bool\n        \"\"\"\n        "
+}