35196a8d623a29fd9d0888b07d48d576846cf1a68fff0b2b570d1f3187eec310

.gitattributes

@@ -129,3 +129,5 @@ find_the_minimum_area_to_cover_all_ones_i/meta.json filter=lfs diff=lfs merge=lf
 find_the_number_of_good_pairs_ii/meta.json filter=lfs diff=lfs merge=lfs -text
 find_the_original_array_of_prefix_xor/meta.json filter=lfs diff=lfs merge=lfs -text
 find_the_score_of_all_prefixes_of_an_array/meta.json filter=lfs diff=lfs merge=lfs -text
+find_x_sum_of_all_k_long_subarrays_ii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+find_x_sum_of_all_k_long_subarrays_ii/meta.json filter=lfs diff=lfs merge=lfs -text

find_the_value_of_the_partition/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(1, findValueOfPartition(Arrays.asList(1,3,2,4)));
+}
+@Test
+public void test2() {
+    assertEquals(9, findValueOfPartition(Arrays.asList(100,1,10)));
+}
+
+}

find_the_width_of_columns_of_a_grid/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 (findColumnWidth [[1],[22],[333]])," [3] (findColumnWidth [[1],[22],[333]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findColumnWidth [[-15,1,3],[15,7,12],[5,6,-2]])," [3,1,2] (findColumnWidth [[-15,1,3],[15,7,12],[5,6,-2]]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

find_the_width_of_columns_of_a_grid/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(3)), findColumnWidth(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1)),new ArrayList<>(Arrays.asList(22)),new ArrayList<>(Arrays.asList(333))))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(3,1,2)), findColumnWidth(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(-15,1,3)),new ArrayList<>(Arrays.asList(15,7,12)),new ArrayList<>(Arrays.asList(5,6,-2))))));
+}
+
+}

find_the_width_of_columns_of_a_grid/ocaml_tests/main.ml

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

find_the_width_of_columns_of_a_grid/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findColumnWidth(List(List(1),List(22),List(333))), List(3))
+  }
+
+  test("test2") {
+    assertEquals(Main.findColumnWidth(List(List(-15,1,3),List(15,7,12),List(5,6,-2))), List(3,1,2))
+  }
+
+}

find_the_xor_of_numbers_which_appear_twice/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+duplicateNumbersXOR :: [Int] -> Int
+duplicateNumbersXOR nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (duplicateNumbersXOR [1,2,1,3])," 1 (duplicateNumbersXOR [1,2,1,3]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (duplicateNumbersXOR [1,2,3])," 0 (duplicateNumbersXOR [1,2,3]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (duplicateNumbersXOR [1,2,2,1])," 3 (duplicateNumbersXOR [1,2,2,1]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (duplicateNumbersXOR [13, 13, 31, 31, 31, 1, 38, 38, 49, 10, 10, 20, 20, 45, 45, 13])," 21 (duplicateNumbersXOR [13, 13, 31, 31, 31, 1, 38, 38, 49, 10, 10, 20, 20, 45, 45, 13]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (duplicateNumbersXOR [38, 15, 15, 44, 19, 44, 35, 35, 31, 6, 6, 33, 34, 16, 16, 36, 36, 47, 20])," 50 (duplicateNumbersXOR [38, 15, 15, 44, 19, 44, 35, 35, 31, 6, 6, 33, 34, 16, 16, 36, 36, 47, 20]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (duplicateNumbersXOR [23, 27, 27, 3, 21])," 27 (duplicateNumbersXOR [23, 27, 27, 3, 21]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (duplicateNumbersXOR [10, 32, 21, 21, 3, 3, 13, 24, 24, 10, 21, 18, 44, 44, 16])," 61 (duplicateNumbersXOR [10, 32, 21, 21, 3, 3, 13, 24, 24, 10, 21, 18, 44, 44, 16]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (duplicateNumbersXOR [19, 19, 36, 42, 42, 1, 24, 24])," 33 (duplicateNumbersXOR [19, 19, 36, 42, 42, 1, 24, 24]))
+
+
+-- 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

find_the_xor_of_numbers_which_appear_twice/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(1, duplicateNumbersXOR(Arrays.asList(1,2,1,3)));
+}
+@Test
+public void test2() {
+    assertEquals(0, duplicateNumbersXOR(Arrays.asList(1,2,3)));
+}
+@Test
+public void test3() {
+    assertEquals(3, duplicateNumbersXOR(Arrays.asList(1,2,2,1)));
+}
+
+}

find_the_xor_of_numbers_which_appear_twice/meta.json

@@ -0,0 +1,120 @@
+{
+    "id": 3428,
+    "name": "find_the_xor_of_numbers_which_appear_twice",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/find-the-xor-of-numbers-which-appear-twice/",
+    "date": "2024-05-11 00:00:00",
+    "task_description": "You are given an array `nums`, where each number in the array appears **either**_ _once_ _or_ _twice. Return the bitwise_ _`XOR` of all the numbers that appear twice in the array, or 0 if no number appears twice. **Example 1:** **Input:** nums = [1,2,1,3] **Output:** 1 **Explanation:** The only number that appears twice in `nums` is 1. **Example 2:** **Input:** nums = [1,2,3] **Output:** 0 **Explanation:** No number appears twice in `nums`. **Example 3:** **Input:** nums = [1,2,2,1] **Output:** 3 **Explanation:** Numbers 1 and 2 appeared twice. `1 XOR 2 == 3`. **Constraints:** `1 <= nums.length <= 50` `1 <= nums[i] <= 50` Each number in `nums` appears either once or twice.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,1,3]",
+            "output": "1 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,2,3]",
+            "output": "0 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [1,2,2,1]",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                13,
+                13,
+                31,
+                31,
+                31,
+                1,
+                38,
+                38,
+                49,
+                10,
+                10,
+                20,
+                20,
+                45,
+                45,
+                13
+            ],
+            "output": 21
+        },
+        {
+            "input": [
+                38,
+                15,
+                15,
+                44,
+                19,
+                44,
+                35,
+                35,
+                31,
+                6,
+                6,
+                33,
+                34,
+                16,
+                16,
+                36,
+                36,
+                47,
+                20
+            ],
+            "output": 50
+        },
+        {
+            "input": [
+                23,
+                27,
+                27,
+                3,
+                21
+            ],
+            "output": 27
+        },
+        {
+            "input": [
+                10,
+                32,
+                21,
+                21,
+                3,
+                3,
+                13,
+                24,
+                24,
+                10,
+                21,
+                18,
+                44,
+                44,
+                16
+            ],
+            "output": 61
+        },
+        {
+            "input": [
+                19,
+                19,
+                36,
+                42,
+                42,
+                1,
+                24,
+                24
+            ],
+            "output": 33
+        }
+    ],
+    "haskell_template": "duplicateNumbersXOR :: [Int] -> Int\nduplicateNumbersXOR nums ",
+    "ocaml_template": "let duplicateNumbersXOR (nums: int list) : int =  ",
+    "scala_template": "def duplicateNumbersXOR(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int duplicateNumbersXOR(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def duplicateNumbersXOR(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

find_the_xor_of_numbers_which_appear_twice/ocaml_tests/main.ml

@@ -0,0 +1,45 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let duplicateNumbersXOR (nums: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 1 (duplicateNumbersXOR [1;2;1;3])
+
+let test2 _ = assert_equal 0 (duplicateNumbersXOR [1;2;3])
+
+let test3 _ = assert_equal 3 (duplicateNumbersXOR [1;2;2;1])
+
+let test4 _ = assert_equal 3 (duplicateNumbersXOR [13; 13; 31; 31; 31; 1; 38; 38; 49; 10; 10; 20; 20; 45; 45; 13])
+
+let test5 _ = assert_equal 3 (duplicateNumbersXOR [38; 15; 15; 44; 19; 44; 35; 35; 31; 6; 6; 33; 34; 16; 16; 36; 36; 47; 20])
+
+let test6 _ = assert_equal 3 (duplicateNumbersXOR [23; 27; 27; 3; 21])
+
+let test7 _ = assert_equal 3 (duplicateNumbersXOR [10; 32; 21; 21; 3; 3; 13; 24; 24; 10; 21; 18; 44; 44; 16])
+
+let test8 _ = assert_equal 3 (duplicateNumbersXOR [19; 19; 36; 42; 42; 1; 24; 24])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for duplicateNumbersXOR" >::: [
+        
+  "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

find_the_xor_of_numbers_which_appear_twice/scala_tests/MySuite.scala

@@ -0,0 +1,36 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.duplicateNumbersXOR(List(1,2,1,3)), 1)
+  }
+
+  test("test2") {
+    assertEquals(Main.duplicateNumbersXOR(List(1,2,3)), 0)
+  }
+
+  test("test3") {
+    assertEquals(Main.duplicateNumbersXOR(List(1,2,2,1)), 3)
+  }
+
+  test("test4") {
+    assertEquals(Main.duplicateNumbersXOR(13,13,31,31,31,1,38,38,49,10,10,20,20,45,45,13), 21)
+  }
+
+  test("test5") {
+    assertEquals(Main.duplicateNumbersXOR(38,15,15,44,19,44,35,35,31,6,6,33,34,16,16,36,36,47,20), 50)
+  }
+
+  test("test6") {
+    assertEquals(Main.duplicateNumbersXOR(23,27,27,3,21), 27)
+  }
+
+  test("test7") {
+    assertEquals(Main.duplicateNumbersXOR(10,32,21,21,3,3,13,24,24,10,21,18,44,44,16), 61)
+  }
+
+  test("test8") {
+    assertEquals(Main.duplicateNumbersXOR(19,19,36,42,42,1,24,24), 33)
+  }
+
+}

find_triangular_sum_of_an_array/haskell_tests/Main.hs

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

find_triangular_sum_of_an_array/java_tests/Main.java

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

find_triangular_sum_of_an_array/ocaml_tests/main.ml

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

find_triangular_sum_of_an_array/scala_tests/MySuite.scala

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

find_valid_pair_of_adjacent_digits_in_string/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+findValidPair :: String -> String
+findValidPair s = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (findValidPair \"2523533 \")," "23" (findValidPair "2523533"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findValidPair \"221 \")," "21" (findValidPair "221"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (findValidPair \"22 \")," "" (findValidPair "22"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (findValidPair  \"756792558394331287478821833597524455433271579117133449657 \")," "" (findValidPair "756792558394331287478821833597524455433271579117133449657"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (findValidPair  \"776518848252212842713961621571355915866157861337944729794669737 \")," "" (findValidPair "776518848252212842713961621571355915866157861337944729794669737"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (findValidPair  \"55866565327817363612729266 \")," "" (findValidPair "55866565327817363612729266"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (findValidPair  \"571827669574991189278818172334595724113191642915149396294781121763455874535672553942951147314215 \")," "" (findValidPair "571827669574991189278818172334595724113191642915149396294781121763455874535672553942951147314215"))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (findValidPair  \"79946134548636737241834 \")," "" (findValidPair "79946134548636737241834"))
+
+
+-- 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

find_valid_pair_of_adjacent_digits_in_string/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("2523533", findValidPair("2523533"));
+}
+@Test
+public void test2() {
+    assertEquals("221", findValidPair("221"));
+}
+@Test
+public void test3() {
+    assertEquals("22", findValidPair("22"));
+}
+
+}

find_valid_pair_of_adjacent_digits_in_string/meta.json

@@ -0,0 +1,52 @@
+{
+    "id": 3736,
+    "name": "find_valid_pair_of_adjacent_digits_in_string",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/find-valid-pair-of-adjacent-digits-in-string/",
+    "date": "2025-01-18 00:00:00",
+    "task_description": "You are given a string `s` consisting only of digits. A **valid pair** is defined as two **adjacent** digits in `s` such that: The first digit is **not equal** to the second. Each digit in the pair appears in `s` **exactly** as many times as its numeric value. Return the first **valid pair** found in the string `s` when traversing from left to right. If no valid pair exists, return an empty string. **Example 1:** **Input:** s = \"2523533\" **Output:** \"23\" **Explanation:** Digit `'2'` appears 2 times and digit `'3'` appears 3 times. Each digit in the pair `\"23\"` appears in `s` exactly as many times as its numeric value. Hence, the output is `\"23\"`. **Example 2:** **Input:** s = \"221\" **Output:** \"21\" **Explanation:** Digit `'2'` appears 2 times and digit `'1'` appears 1 time. Hence, the output is `\"21\"`. **Example 3:** **Input:** s = \"22\" **Output:** \"\" **Explanation:** There are no valid adjacent pairs. **Constraints:** `2 <= s.length <= 100` `s` only consists of digits from `'1'` to `'9'`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"2523533\"",
+            "output": "\"23\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"221\"",
+            "output": "\"21\" "
+        },
+        {
+            "label": "Example 3",
+            "input": "s = \"22\"",
+            "output": "\"\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "756792558394331287478821833597524455433271579117133449657",
+            "output": ""
+        },
+        {
+            "input": "776518848252212842713961621571355915866157861337944729794669737",
+            "output": ""
+        },
+        {
+            "input": "55866565327817363612729266",
+            "output": ""
+        },
+        {
+            "input": "571827669574991189278818172334595724113191642915149396294781121763455874535672553942951147314215",
+            "output": ""
+        },
+        {
+            "input": "79946134548636737241834",
+            "output": ""
+        }
+    ],
+    "haskell_template": "findValidPair :: String -> String\nfindValidPair s ",
+    "ocaml_template": "let findValidPair (s: string) : string =  ",
+    "scala_template": "def findValidPair(s: String): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String findValidPair(String s) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findValidPair(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: str\n        \"\"\"\n        "
+}

find_valid_pair_of_adjacent_digits_in_string/ocaml_tests/main.ml

@@ -0,0 +1,45 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let findValidPair (s: string) : string =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "23" (findValidPair "2523533")
+
+let test2 _ = assert_equal "21" (findValidPair "221")
+
+let test3 _ = assert_equal "" (findValidPair "22")
+
+let test4 _ = assert_equal "" (findValidPair "756792558394331287478821833597524455433271579117133449657")
+
+let test5 _ = assert_equal "" (findValidPair "776518848252212842713961621571355915866157861337944729794669737")
+
+let test6 _ = assert_equal "" (findValidPair "55866565327817363612729266")
+
+let test7 _ = assert_equal "" (findValidPair "571827669574991189278818172334595724113191642915149396294781121763455874535672553942951147314215")
+
+let test8 _ = assert_equal "" (findValidPair "79946134548636737241834")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for findValidPair" >::: [
+        
+  "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

find_valid_pair_of_adjacent_digits_in_string/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findValidPair("2523533"), "23")
+  }
+
+  test("test2") {
+    assertEquals(Main.findValidPair("221"), "21")
+  }
+
+  test("test3") {
+    assertEquals(Main.findValidPair("22"), "")
+  }
+
+}

find_words_containing_character/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(new ArrayList<>(Arrays.asList(0,1)), findWordsContaining(new ArrayList<>(Arrays.asList("leet","code")), "e"));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(0,2)), findWordsContaining(new ArrayList<>(Arrays.asList("abc","bcd","aaaa","cbc")), "a"));
+}
+@Test
+public void test3() {
+    assertEquals([], findWordsContaining(new ArrayList<>(Arrays.asList("abc","bcd","aaaa","cbc")), "z"));
+}
+
+}

find_x_sum_of_all_k_long_subarrays_i/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 (findXSum [1,1,2,2,3,4,2,3] 6 2)," [6,10,12] (findXSum [1,1,2,2,3,4,2,3] 6 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findXSum [3,8,7,8,7,5] 2 2)," [11,15,15,15,12] (findXSum [3,8,7,8,7,5] 2 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (findXSum [2, 37, 16, 16, 44, 19, 33, 35, 17, 50, 45, 2, 2, 33, 8] 2 1)," [37,37,32,44,44,33,35,35,50,50,45,4,33,33] (findXSum [2, 37, 16, 16, 44, 19, 33, 35, 17, 50, 45, 2, 2, 33, 8] 2 1))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (findXSum [6, 26] 2 2)," [32] (findXSum [6, 26] 2 2))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (findXSum [30, 38, 11, 11, 24, 22, 49, 18] 5 1)," [22,22,22,49] (findXSum [30, 38, 11, 11, 24, 22, 49, 18] 5 1))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (findXSum [14, 11, 30, 6, 38, 20, 36, 15, 41, 13] 3 1)," [30,30,38,38,38,36,41,41] (findXSum [14, 11, 30, 6, 38, 20, 36, 15, 41, 13] 3 1))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (findXSum [39, 17, 26, 41, 25, 10, 14, 12] 5 4)," [131,109,106,92] (findXSum [39, 17, 26, 41, 25, 10, 14, 12] 5 4))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (findXSum [30, 41, 16, 1, 2, 32, 7, 39, 14, 6, 16, 20, 44, 17, 32, 21, 4, 36, 6, 43, 21, 36, 33, 25, 47, 21, 25] 9 4)," [142,128,117,107,135,135,135,136,117,133,133,155,165,189,190,190,195,204,182] (findXSum [30, 41, 16, 1, 2, 32, 7, 39, 14, 6, 16, 20, 44, 17, 32, 21, 4, 36, 6, 43, 21, 36, 33, 25, 47, 21, 25] 9 4))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (findXSum [9, 46, 14, 44, 47, 16, 45, 14, 13, 17, 12, 2, 30, 30, 9, 25, 4, 2, 29, 39] 14 7)," [287,287,266,254,214,196,219] (findXSum [9, 46, 14, 44, 47, 16, 45, 14, 13, 17, 12, 2, 30, 30, 9, 25, 4, 2, 29, 39] 14 7))
+
+
+-- 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

find_x_sum_of_all_k_long_subarrays_i/java_tests/Main.java

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

find_x_sum_of_all_k_long_subarrays_i/meta.json

@@ -0,0 +1,338 @@
+{
+    "id": 3610,
+    "name": "find_x_sum_of_all_k_long_subarrays_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/find-x-sum-of-all-k-long-subarrays-i/",
+    "date": "2024-10-06 00:00:00",
+    "task_description": "You are given an array `nums` of `n` integers and two integers `k` and `x`. The **x-sum** of an array is calculated by the following procedure: Count the occurrences of all elements in the array. Keep only the occurrences of the top `x` most frequent elements. If two elements have the same number of occurrences, the element with the **bigger** value is considered more frequent. Calculate the sum of the resulting array. **Note** that if an array has less than `x` distinct elements, its **x-sum** is the sum of the array. Return an integer array `answer` of length `n - k + 1` where `answer[i]` is the **x-sum** of the subarray `nums[i..i + k - 1]`. **Example 1:** **Input:** nums = [1,1,2,2,3,4,2,3], k = 6, x = 2 **Output:** [6,10,12] **Explanation:** For subarray `[1, 1, 2, 2, 3, 4]`, only elements 1 and 2 will be kept in the resulting array. Hence, `answer[0] = 1 + 1 + 2 + 2`. For subarray `[1, 2, 2, 3, 4, 2]`, only elements 2 and 4 will be kept in the resulting array. Hence, `answer[1] = 2 + 2 + 2 + 4`. Note that 4 is kept in the array since it is bigger than 3 and 1 which occur the same number of times. For subarray `[2, 2, 3, 4, 2, 3]`, only elements 2 and 3 are kept in the resulting array. Hence, `answer[2] = 2 + 2 + 2 + 3 + 3`. **Example 2:** **Input:** nums = [3,8,7,8,7,5], k = 2, x = 2 **Output:** [11,15,15,15,12] **Explanation:** Since `k == x`, `answer[i]` is equal to the sum of the subarray `nums[i..i + k - 1]`. **Constraints:** `1 <= n == nums.length <= 50` `1 <= nums[i] <= 50` `1 <= x <= k <= nums.length`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,1,2,2,3,4,2,3], k = 6, x = 2",
+            "output": "[6,10,12] "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [3,8,7,8,7,5], k = 2, x = 2",
+            "output": "[11,15,15,15,12] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    2,
+                    37,
+                    16,
+                    16,
+                    44,
+                    19,
+                    33,
+                    35,
+                    17,
+                    50,
+                    45,
+                    2,
+                    2,
+                    33,
+                    8
+                ],
+                2,
+                1
+            ],
+            "output": [
+                37,
+                37,
+                32,
+                44,
+                44,
+                33,
+                35,
+                35,
+                50,
+                50,
+                45,
+                4,
+                33,
+                33
+            ]
+        },
+        {
+            "input": [
+                [
+                    6,
+                    26
+                ],
+                2,
+                2
+            ],
+            "output": [
+                32
+            ]
+        },
+        {
+            "input": [
+                [
+                    30,
+                    38,
+                    11,
+                    11,
+                    24,
+                    22,
+                    49,
+                    18
+                ],
+                5,
+                1
+            ],
+            "output": [
+                22,
+                22,
+                22,
+                49
+            ]
+        },
+        {
+            "input": [
+                [
+                    14,
+                    11,
+                    30,
+                    6,
+                    38,
+                    20,
+                    36,
+                    15,
+                    41,
+                    13
+                ],
+                3,
+                1
+            ],
+            "output": [
+                30,
+                30,
+                38,
+                38,
+                38,
+                36,
+                41,
+                41
+            ]
+        },
+        {
+            "input": [
+                [
+                    39,
+                    17,
+                    26,
+                    41,
+                    25,
+                    10,
+                    14,
+                    12
+                ],
+                5,
+                4
+            ],
+            "output": [
+                131,
+                109,
+                106,
+                92
+            ]
+        },
+        {
+            "input": [
+                [
+                    30,
+                    41,
+                    16,
+                    1,
+                    2,
+                    32,
+                    7,
+                    39,
+                    14,
+                    6,
+                    16,
+                    20,
+                    44,
+                    17,
+                    32,
+                    21,
+                    4,
+                    36,
+                    6,
+                    43,
+                    21,
+                    36,
+                    33,
+                    25,
+                    47,
+                    21,
+                    25
+                ],
+                9,
+                4
+            ],
+            "output": [
+                142,
+                128,
+                117,
+                107,
+                135,
+                135,
+                135,
+                136,
+                117,
+                133,
+                133,
+                155,
+                165,
+                189,
+                190,
+                190,
+                195,
+                204,
+                182
+            ]
+        },
+        {
+            "input": [
+                [
+                    9,
+                    46,
+                    14,
+                    44,
+                    47,
+                    16,
+                    45,
+                    14,
+                    13,
+                    17,
+                    12,
+                    2,
+                    30,
+                    30,
+                    9,
+                    25,
+                    4,
+                    2,
+                    29,
+                    39
+                ],
+                14,
+                7
+            ],
+            "output": [
+                287,
+                287,
+                266,
+                254,
+                214,
+                196,
+                219
+            ]
+        },
+        {
+            "input": [
+                [
+                    46,
+                    8,
+                    9,
+                    11,
+                    19,
+                    22,
+                    45,
+                    5,
+                    15,
+                    22,
+                    39,
+                    12,
+                    47,
+                    25,
+                    26,
+                    36,
+                    5,
+                    25,
+                    14,
+                    45,
+                    26,
+                    36,
+                    4,
+                    20,
+                    43,
+                    48,
+                    45,
+                    19,
+                    6,
+                    23
+                ],
+                30,
+                8
+            ],
+            "output": [
+                449
+            ]
+        },
+        {
+            "input": [
+                [
+                    24,
+                    5
+                ],
+                2,
+                1
+            ],
+            "output": [
+                24
+            ]
+        },
+        {
+            "input": [
+                [
+                    21,
+                    3,
+                    47,
+                    33,
+                    8,
+                    33,
+                    33,
+                    34,
+                    14,
+                    27,
+                    15,
+                    21,
+                    6,
+                    39,
+                    39,
+                    31,
+                    33,
+                    29
+                ],
+                7,
+                1
+            ],
+            "output": [
+                99,
+                99,
+                99,
+                99,
+                66,
+                66,
+                34,
+                39,
+                78,
+                78,
+                78,
+                78
+            ]
+        }
+    ],
+    "haskell_template": "findXSum :: [Int] -> Int -> Int -> [Int]\nfindXSum nums k x ",
+    "ocaml_template": "let findXSum (nums: int list) (k: int) (x: int) : int list =  ",
+    "scala_template": "def findXSum(nums: List[Int],k: Int,x: Int): List[Int] = { \n    \n}",
+    "java_template": "class Solution {\n    public int[] findXSum(int[] nums, int k, int x) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findXSum(self, nums, k, x):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :type x: int\n        :rtype: List[int]\n        \"\"\"\n        "
+}

find_x_sum_of_all_k_long_subarrays_i/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal [6;10;12] (findXSum [1;1;2;2;3;4;2;3] 6 2)
+
+let test2 _ = assert_equal [11;15;15;15;12] (findXSum [3;8;7;8;7;5] 2 2)
+
+let test3 _ = assert_equal [37;37;32;44;44;33;35;35;50;50;45;4;33;33] (findXSum [2; 37; 16; 16; 44; 19; 33; 35; 17; 50; 45; 2; 2; 33; 8] 2 1)
+
+let test4 _ = assert_equal [32] (findXSum [6; 26] 2 2)
+
+let test5 _ = assert_equal [22;22;22;49] (findXSum [30; 38; 11; 11; 24; 22; 49; 18] 5 1)
+
+let test6 _ = assert_equal [30;30;38;38;38;36;41;41] (findXSum [14; 11; 30; 6; 38; 20; 36; 15; 41; 13] 3 1)
+
+let test7 _ = assert_equal [131;109;106;92] (findXSum [39; 17; 26; 41; 25; 10; 14; 12] 5 4)
+
+let test8 _ = assert_equal [142;128;117;107;135;135;135;136;117;133;133;155;165;189;190;190;195;204;182] (findXSum [30; 41; 16; 1; 2; 32; 7; 39; 14; 6; 16; 20; 44; 17; 32; 21; 4; 36; 6; 43; 21; 36; 33; 25; 47; 21; 25] 9 4)
+
+let test9 _ = assert_equal [287;287;266;254;214;196;219] (findXSum [9; 46; 14; 44; 47; 16; 45; 14; 13; 17; 12; 2; 30; 30; 9; 25; 4; 2; 29; 39] 14 7)
+
+let test10 _ = assert_equal [449] (findXSum [46; 8; 9; 11; 19; 22; 45; 5; 15; 22; 39; 12; 47; 25; 26; 36; 5; 25; 14; 45; 26; 36; 4; 20; 43; 48; 45; 19; 6; 23] 30 8)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for findXSum" >::: [
+        
+  "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

find_x_sum_of_all_k_long_subarrays_i/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findXSum(List(1,1,2,2,3,4,2,3),6,2), List(6,10,12))
+  }
+
+  test("test2") {
+    assertEquals(Main.findXSum(List(3,8,7,8,7,5),2,2), List(11,15,15,15,12))
+  }
+
+  test("test3") {
+    assertEquals(Main.findXSum(List(2, 37, 16, 16, 44, 19, 33, 35, 17, 50, 45, 2, 2, 33, 8),2,1), List(37,37,32,44,44,33,35,35,50,50,45,4,33,33))
+  }
+
+  test("test4") {
+    assertEquals(Main.findXSum(List(6, 26),2,2), List(32))
+  }
+
+  test("test5") {
+    assertEquals(Main.findXSum(List(30, 38, 11, 11, 24, 22, 49, 18),5,1), List(22,22,22,49))
+  }
+
+  test("test6") {
+    assertEquals(Main.findXSum(List(14, 11, 30, 6, 38, 20, 36, 15, 41, 13),3,1), List(30,30,38,38,38,36,41,41))
+  }
+
+  test("test7") {
+    assertEquals(Main.findXSum(List(39, 17, 26, 41, 25, 10, 14, 12),5,4), List(131,109,106,92))
+  }
+
+  test("test8") {
+    assertEquals(Main.findXSum(List(30, 41, 16, 1, 2, 32, 7, 39, 14, 6, 16, 20, 44, 17, 32, 21, 4, 36, 6, 43, 21, 36, 33, 25, 47, 21, 25),9,4), List(142,128,117,107,135,135,135,136,117,133,133,155,165,189,190,190,195,204,182))
+  }
+
+  test("test9") {
+    assertEquals(Main.findXSum(List(9, 46, 14, 44, 47, 16, 45, 14, 13, 17, 12, 2, 30, 30, 9, 25, 4, 2, 29, 39),14,7), List(287,287,266,254,214,196,219))
+  }
+
+  test("test10") {
+    assertEquals(Main.findXSum(List(46, 8, 9, 11, 19, 22, 45, 5, 15, 22, 39, 12, 47, 25, 26, 36, 5, 25, 14, 45, 26, 36, 4, 20, 43, 48, 45, 19, 6, 23),30,8), List(449))
+  }
+
+}

find_x_sum_of_all_k_long_subarrays_ii/haskell_tests/Main.hs

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

find_x_sum_of_all_k_long_subarrays_ii/java_tests/Main.java

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

find_x_sum_of_all_k_long_subarrays_ii/meta.json

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

find_xor_beauty_of_array/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(5, xorBeauty(Arrays.asList(1,4)));
+}
+@Test
+public void test2() {
+    assertEquals(34, xorBeauty(Arrays.asList(15,45,20,2,34,35,5,44,32,30)));
+}
+
+}

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

first_completely_painted_row_or_column/java_tests/Main.java

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

first_completely_painted_row_or_column/meta.json

@@ -0,0 +1,1089 @@
+{
+    "id": 2685,
+    "name": "first_completely_painted_row_or_column",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/first-completely-painted-row-or-column/",
+    "date": "1682208000000",
+    "task_description": "You are given a **0-indexed** integer array `arr`, and an `m x n` integer **matrix** `mat`. `arr` and `mat` both contain **all** the integers in the range `[1, m * n]`. Go through each index `i` in `arr` starting from index `0` and paint the cell in `mat` containing the integer `arr[i]`. Return _the smallest index_ `i` _at which either a row or a column will be completely painted in_ `mat`. **Example 1:** ``` **Input:** arr = [1,3,4,2], mat = [[1,4],[2,3]] **Output:** 2 **Explanation:** The moves are shown in order, and both the first row and second column of the matrix become fully painted at arr[2]. ``` **Example 2:** ``` **Input:** arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]] **Output:** 3 **Explanation:** The second column becomes fully painted at arr[3]. ``` **Constraints:** `m == mat.length` `n = mat[i].length` `arr.length == m * n` `1 <= m, n <= 105` `1 <= m * n <= 105` `1 <= arr[i], mat[r][c] <= m * n` All the integers of `arr` are **unique**. All the integers of `mat` are **unique**.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "arr = [1,3,4,2], mat = [[1,4],[2,3]]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]]",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    67,
+                    23,
+                    70,
+                    9,
+                    40,
+                    61,
+                    45,
+                    25,
+                    47,
+                    19,
+                    30,
+                    18,
+                    58,
+                    39,
+                    15,
+                    66,
+                    35,
+                    20,
+                    8,
+                    7,
+                    54,
+                    6,
+                    41,
+                    34,
+                    53,
+                    10,
+                    60,
+                    43,
+                    63,
+                    13,
+                    68,
+                    4,
+                    16,
+                    31,
+                    52,
+                    22,
+                    49,
+                    27,
+                    57,
+                    69,
+                    29,
+                    12,
+                    48,
+                    24,
+                    1,
+                    50,
+                    64,
+                    17,
+                    44,
+                    3,
+                    51,
+                    14,
+                    59,
+                    46,
+                    28,
+                    2,
+                    36,
+                    65,
+                    32,
+                    42,
+                    5,
+                    55,
+                    62,
+                    26,
+                    38,
+                    56,
+                    37,
+                    11,
+                    33,
+                    21
+                ],
+                [
+                    [
+                        67,
+                        23,
+                        70,
+                        9,
+                        40,
+                        61,
+                        45,
+                        25,
+                        47,
+                        19
+                    ],
+                    [
+                        30,
+                        18,
+                        58,
+                        39,
+                        15,
+                        66,
+                        35,
+                        20,
+                        8,
+                        7
+                    ],
+                    [
+                        54,
+                        6,
+                        41,
+                        34,
+                        53,
+                        10,
+                        60,
+                        43,
+                        63,
+                        13
+                    ],
+                    [
+                        68,
+                        4,
+                        16,
+                        31,
+                        52,
+                        22,
+                        49,
+                        27,
+                        57,
+                        69
+                    ],
+                    [
+                        29,
+                        12,
+                        48,
+                        24,
+                        1,
+                        50,
+                        64,
+                        17,
+                        44,
+                        3
+                    ],
+                    [
+                        51,
+                        14,
+                        59,
+                        46,
+                        28,
+                        2,
+                        36,
+                        65,
+                        32,
+                        42
+                    ],
+                    [
+                        5,
+                        55,
+                        62,
+                        26,
+                        38,
+                        56,
+                        37,
+                        11,
+                        33,
+                        21
+                    ]
+                ]
+            ],
+            "output": 9
+        },
+        {
+            "input": [
+                [
+                    37,
+                    17,
+                    42,
+                    38,
+                    31,
+                    4,
+                    41,
+                    8,
+                    12,
+                    28,
+                    10,
+                    2,
+                    26,
+                    32,
+                    36,
+                    16,
+                    45,
+                    23,
+                    15,
+                    30,
+                    7,
+                    35,
+                    25,
+                    43,
+                    1,
+                    3,
+                    47,
+                    39,
+                    27,
+                    34,
+                    13,
+                    50,
+                    6,
+                    49,
+                    5,
+                    22,
+                    33,
+                    11,
+                    29,
+                    44,
+                    18,
+                    24,
+                    21,
+                    40,
+                    20,
+                    19,
+                    48,
+                    46,
+                    9,
+                    14
+                ],
+                [
+                    [
+                        37,
+                        17,
+                        42,
+                        38,
+                        31
+                    ],
+                    [
+                        4,
+                        41,
+                        8,
+                        12,
+                        28
+                    ],
+                    [
+                        10,
+                        2,
+                        26,
+                        32,
+                        36
+                    ],
+                    [
+                        16,
+                        45,
+                        23,
+                        15,
+                        30
+                    ],
+                    [
+                        7,
+                        35,
+                        25,
+                        43,
+                        1
+                    ],
+                    [
+                        3,
+                        47,
+                        39,
+                        27,
+                        34
+                    ],
+                    [
+                        13,
+                        50,
+                        6,
+                        49,
+                        5
+                    ],
+                    [
+                        22,
+                        33,
+                        11,
+                        29,
+                        44
+                    ],
+                    [
+                        18,
+                        24,
+                        21,
+                        40,
+                        20
+                    ],
+                    [
+                        19,
+                        48,
+                        46,
+                        9,
+                        14
+                    ]
+                ]
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                [
+                    5,
+                    2,
+                    3,
+                    1,
+                    6,
+                    4,
+                    7
+                ],
+                [
+                    [
+                        5,
+                        2,
+                        3,
+                        1,
+                        6,
+                        4,
+                        7
+                    ]
+                ]
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    66,
+                    57,
+                    19,
+                    17,
+                    29,
+                    50,
+                    87,
+                    20,
+                    8,
+                    37,
+                    16,
+                    43,
+                    84,
+                    3,
+                    78,
+                    49,
+                    13,
+                    36,
+                    89,
+                    70,
+                    79,
+                    86,
+                    40,
+                    1,
+                    2,
+                    18,
+                    27,
+                    42,
+                    48,
+                    28,
+                    6,
+                    47,
+                    81,
+                    31,
+                    15,
+                    26,
+                    25,
+                    5,
+                    88,
+                    67,
+                    44,
+                    53,
+                    54,
+                    52,
+                    56,
+                    45,
+                    55,
+                    63,
+                    38,
+                    83,
+                    11,
+                    85,
+                    60,
+                    14,
+                    10,
+                    68,
+                    90,
+                    61,
+                    24,
+                    22,
+                    71,
+                    72,
+                    32,
+                    12,
+                    64,
+                    7,
+                    74,
+                    4,
+                    21,
+                    39,
+                    59,
+                    58,
+                    30,
+                    34,
+                    35,
+                    77,
+                    76,
+                    75,
+                    46,
+                    51,
+                    80,
+                    9,
+                    33,
+                    82,
+                    62,
+                    73,
+                    65,
+                    41,
+                    69,
+                    23
+                ],
+                [
+                    [
+                        66,
+                        57,
+                        19,
+                        17,
+                        29,
+                        50,
+                        87,
+                        20,
+                        8,
+                        37
+                    ],
+                    [
+                        16,
+                        43,
+                        84,
+                        3,
+                        78,
+                        49,
+                        13,
+                        36,
+                        89,
+                        70
+                    ],
+                    [
+                        79,
+                        86,
+                        40,
+                        1,
+                        2,
+                        18,
+                        27,
+                        42,
+                        48,
+                        28
+                    ],
+                    [
+                        6,
+                        47,
+                        81,
+                        31,
+                        15,
+                        26,
+                        25,
+                        5,
+                        88,
+                        67
+                    ],
+                    [
+                        44,
+                        53,
+                        54,
+                        52,
+                        56,
+                        45,
+                        55,
+                        63,
+                        38,
+                        83
+                    ],
+                    [
+                        11,
+                        85,
+                        60,
+                        14,
+                        10,
+                        68,
+                        90,
+                        61,
+                        24,
+                        22
+                    ],
+                    [
+                        71,
+                        72,
+                        32,
+                        12,
+                        64,
+                        7,
+                        74,
+                        4,
+                        21,
+                        39
+                    ],
+                    [
+                        59,
+                        58,
+                        30,
+                        34,
+                        35,
+                        77,
+                        76,
+                        75,
+                        46,
+                        51
+                    ],
+                    [
+                        80,
+                        9,
+                        33,
+                        82,
+                        62,
+                        73,
+                        65,
+                        41,
+                        69,
+                        23
+                    ]
+                ]
+            ],
+            "output": 9
+        },
+        {
+            "input": [
+                [
+                    47,
+                    35,
+                    34,
+                    10,
+                    42,
+                    9,
+                    38,
+                    8,
+                    49,
+                    40,
+                    52,
+                    32,
+                    16,
+                    25,
+                    12,
+                    30,
+                    48,
+                    2,
+                    7,
+                    44,
+                    26,
+                    45,
+                    1,
+                    13,
+                    54,
+                    15,
+                    50,
+                    43,
+                    11,
+                    37,
+                    3,
+                    23,
+                    17,
+                    36,
+                    27,
+                    51,
+                    39,
+                    29,
+                    41,
+                    53,
+                    19,
+                    24,
+                    20,
+                    33,
+                    6,
+                    14,
+                    28,
+                    4,
+                    5,
+                    46,
+                    22,
+                    21,
+                    18,
+                    31
+                ],
+                [
+                    [
+                        47,
+                        35,
+                        34,
+                        10,
+                        42,
+                        9,
+                        38,
+                        8,
+                        49
+                    ],
+                    [
+                        40,
+                        52,
+                        32,
+                        16,
+                        25,
+                        12,
+                        30,
+                        48,
+                        2
+                    ],
+                    [
+                        7,
+                        44,
+                        26,
+                        45,
+                        1,
+                        13,
+                        54,
+                        15,
+                        50
+                    ],
+                    [
+                        43,
+                        11,
+                        37,
+                        3,
+                        23,
+                        17,
+                        36,
+                        27,
+                        51
+                    ],
+                    [
+                        39,
+                        29,
+                        41,
+                        53,
+                        19,
+                        24,
+                        20,
+                        33,
+                        6
+                    ],
+                    [
+                        14,
+                        28,
+                        4,
+                        5,
+                        46,
+                        22,
+                        21,
+                        18,
+                        31
+                    ]
+                ]
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                [
+                    22,
+                    14,
+                    2,
+                    20,
+                    24,
+                    16,
+                    5,
+                    6,
+                    9,
+                    10,
+                    12,
+                    21,
+                    1,
+                    13,
+                    11,
+                    8,
+                    4,
+                    19,
+                    15,
+                    3,
+                    18,
+                    17,
+                    23,
+                    7
+                ],
+                [
+                    [
+                        22,
+                        14,
+                        2,
+                        20,
+                        24,
+                        16
+                    ],
+                    [
+                        5,
+                        6,
+                        9,
+                        10,
+                        12,
+                        21
+                    ],
+                    [
+                        1,
+                        13,
+                        11,
+                        8,
+                        4,
+                        19
+                    ],
+                    [
+                        15,
+                        3,
+                        18,
+                        17,
+                        23,
+                        7
+                    ]
+                ]
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                [
+                    40,
+                    16,
+                    15,
+                    28,
+                    26,
+                    43,
+                    22,
+                    31,
+                    49,
+                    10,
+                    4,
+                    29,
+                    2,
+                    32,
+                    11,
+                    21,
+                    47,
+                    45,
+                    20,
+                    41,
+                    13,
+                    48,
+                    44,
+                    38,
+                    46,
+                    19,
+                    36,
+                    23,
+                    5,
+                    12,
+                    8,
+                    35,
+                    9,
+                    14,
+                    27,
+                    1,
+                    33,
+                    24,
+                    3,
+                    34,
+                    18,
+                    37,
+                    7,
+                    50,
+                    42,
+                    17,
+                    25,
+                    30,
+                    6,
+                    39
+                ],
+                [
+                    [
+                        40,
+                        16,
+                        15,
+                        28,
+                        26,
+                        43,
+                        22,
+                        31,
+                        49,
+                        10
+                    ],
+                    [
+                        4,
+                        29,
+                        2,
+                        32,
+                        11,
+                        21,
+                        47,
+                        45,
+                        20,
+                        41
+                    ],
+                    [
+                        13,
+                        48,
+                        44,
+                        38,
+                        46,
+                        19,
+                        36,
+                        23,
+                        5,
+                        12
+                    ],
+                    [
+                        8,
+                        35,
+                        9,
+                        14,
+                        27,
+                        1,
+                        33,
+                        24,
+                        3,
+                        34
+                    ],
+                    [
+                        18,
+                        37,
+                        7,
+                        50,
+                        42,
+                        17,
+                        25,
+                        30,
+                        6,
+                        39
+                    ]
+                ]
+            ],
+            "output": 9
+        },
+        {
+            "input": [
+                [
+                    25,
+                    24,
+                    9,
+                    5,
+                    2,
+                    14,
+                    3,
+                    19,
+                    11,
+                    28,
+                    13,
+                    4,
+                    23,
+                    18,
+                    29,
+                    16,
+                    20,
+                    15,
+                    8,
+                    30,
+                    7,
+                    26,
+                    27,
+                    12,
+                    21,
+                    22,
+                    1,
+                    17,
+                    6,
+                    10
+                ],
+                [
+                    [
+                        25,
+                        24,
+                        9
+                    ],
+                    [
+                        5,
+                        2,
+                        14
+                    ],
+                    [
+                        3,
+                        19,
+                        11
+                    ],
+                    [
+                        28,
+                        13,
+                        4
+                    ],
+                    [
+                        23,
+                        18,
+                        29
+                    ],
+                    [
+                        16,
+                        20,
+                        15
+                    ],
+                    [
+                        8,
+                        30,
+                        7
+                    ],
+                    [
+                        26,
+                        27,
+                        12
+                    ],
+                    [
+                        21,
+                        22,
+                        1
+                    ],
+                    [
+                        17,
+                        6,
+                        10
+                    ]
+                ]
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    33,
+                    9,
+                    34,
+                    29,
+                    39,
+                    20,
+                    38,
+                    35,
+                    7,
+                    21,
+                    28,
+                    13,
+                    23,
+                    19,
+                    40,
+                    4,
+                    17,
+                    2,
+                    14,
+                    5,
+                    27,
+                    12,
+                    24,
+                    22,
+                    15,
+                    8,
+                    30,
+                    16,
+                    3,
+                    10,
+                    1,
+                    6,
+                    26,
+                    18,
+                    32,
+                    11,
+                    36,
+                    31,
+                    25,
+                    37
+                ],
+                [
+                    [
+                        33,
+                        9,
+                        34,
+                        29
+                    ],
+                    [
+                        39,
+                        20,
+                        38,
+                        35
+                    ],
+                    [
+                        7,
+                        21,
+                        28,
+                        13
+                    ],
+                    [
+                        23,
+                        19,
+                        40,
+                        4
+                    ],
+                    [
+                        17,
+                        2,
+                        14,
+                        5
+                    ],
+                    [
+                        27,
+                        12,
+                        24,
+                        22
+                    ],
+                    [
+                        15,
+                        8,
+                        30,
+                        16
+                    ],
+                    [
+                        3,
+                        10,
+                        1,
+                        6
+                    ],
+                    [
+                        26,
+                        18,
+                        32,
+                        11
+                    ],
+                    [
+                        36,
+                        31,
+                        25,
+                        37
+                    ]
+                ]
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                [
+                    4,
+                    5,
+                    1,
+                    3,
+                    2,
+                    6
+                ],
+                [
+                    [
+                        4,
+                        5
+                    ],
+                    [
+                        1,
+                        3
+                    ],
+                    [
+                        2,
+                        6
+                    ]
+                ]
+            ],
+            "output": 1
+        }
+    ],
+    "haskell_template": "firstCompleteIndex :: [Int] -> [[Int]] -> Int\nfirstCompleteIndex arr mat ",
+    "ocaml_template": "let firstCompleteIndex (arr: int list) (mat: int list list) : int =  ",
+    "scala_template": "def firstCompleteIndex(arr: List[Int],mat: List[List[Int]]): Int = { \n    \n}",
+    "java_template": "public static int firstCompleteIndex(List<Integer> arr, List<List<Integer>> mat) {\n\n}",
+    "python_template": "class Solution(object):\n    def firstCompleteIndex(self, arr, mat):\n        \"\"\"\n        :type arr: List[int]\n        :type mat: List[List[int]]\n        :rtype: int\n        \"\"\"\n        "
+}

first_completely_painted_row_or_column/ocaml_tests/main.ml

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

first_completely_painted_row_or_column/scala_tests/MySuite.scala

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