ad921e5faff2f2cf3ba86483dabf36386cbb4b529efacf07dfa1b2d84aed393c

.gitattributes

@@ -278,3 +278,5 @@ shortest_impossible_sequence_of_rolls/meta.json filter=lfs diff=lfs merge=lfs -t
 shortest_subarray_with_or_at_least_k_ii/meta.json filter=lfs diff=lfs merge=lfs -text
 sliding_subarray_beauty/meta.json filter=lfs diff=lfs merge=lfs -text
 smallest_missing_non_negative_integer_after_operations/meta.json filter=lfs diff=lfs merge=lfs -text
+solving_questions_with_brainpower/meta.json filter=lfs diff=lfs merge=lfs -text
+sorted_gcd_pair_queries/meta.json filter=lfs diff=lfs merge=lfs -text

smallest_substring_with_identical_characters_i/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (minLength "000001" 1)
+
+let test2 _ = assert_equal 1 (minLength "0000" 2)
+
+let test3 _ = assert_equal 1 (minLength "111011101011001101110101111010001001010111111001010111011001110100010010101010101000111110010110000010000101010100111111001101100101110010100011111000111001100101001101100101111001011010110000001110111011001010101101110110100000010100001100011110111010011110101001010010010100011011110000101010010010101101000001110110100011111101011101000010001011101110000001110101110111110111011000111001101010110101001111101000111010101001101100010011111011010101011011110001011011000100011111111100100000111110010100010100000101000111100100001010000100011011001011100001100011010111001011010101001001101001111110000001010011100001000000100011011111110001011000101000001011111100111111010011100010111001110010000100100000011111000111000110001001101010001100111100000001010111000110011101010110010010100100000100" 791)
+
+let test4 _ = assert_equal 1 (minLength "010001010100011010001010001011011101000001011110000100101001010000100001010111110101011001000100110011111111011101101100101110001111100011110101011011000001101001111110000010001100011110100011011111010101100010000010100000" 168)
+
+let test5 _ = assert_equal 2 (minLength "0001001111010111010011001101110100000111011111110001001110111111100110011000110001111000000110100111100110010101000101001001100100001000001100010011001110000010110111001101100101011011100010101110011010100010110010100111111111010001011001101000011000100010110001111100100111011111000000001101101101110000111010000010010011001111101111111011110011010101101101011001100111110111011001000101000101011101000101001001000010110111101011100001100000001110010110000100101010110100110100010011101011111000001001111010110111010101001101110100111110000101000000011111101100000110001010000001100001100110000111000" 255)
+
+let test6 _ = assert_equal 1 (minLength "110101001110100001010000010010111100110001011110010111011111111101010010101000010100001000010100100101110100111001010110010000001111011110111101111001110010111111001111100100110110100000101111111001101111110101011000001011110100100010001001010101001000001001001010000001110000010110000000000101111101010011110000011001100011111101000010010011100010100001001001001000010011100010110011100010011101100111100000010110010001111101011011000100111011010000011100000101111100101101100111001111001010101011111010001110000111011101001011010100010000110000011010101010001001110101" 527)
+
+let test7 _ = assert_equal 1 (minLength "010000110000101101001100001101010000100000110100000010010111001111001001100010111100001001101111101101101011011110100010110101001111000001111010110100001101111001110100110000010001010101101110001110000101111000111111110001100110011011100001010000010000100010010010110111100100110101111011110011111100100111010010011000000001001110101000100110110110110011011111100111000010010100000010000101001111001111110100101010001111110001001100001010110000111000010000010001110101111010011000111101110001111010011001001100011011110110101100100010010011011110010100100101010010101100001011010001011011001100000011100100010111101101111111000000010110001010001010011011100000101011110000101011001100100001111100010001011010110000000000010110011" 604)
+
+let test8 _ = assert_equal 1 (minLength "00101110001110010110011011100000010001001101001001000100111111001010110011000001110000001100011011100111101010110011111001100111110000011101011110010111010101010010001100111101000001001001111010010111001010101110010000010101100100011010000010110100010111111011110110101110110011010011011100001011101000110111100001110111101001111100100011001011000111100001101111110111000001011100010011111010110100010100000100111000100101101100010110100110110100011101010000111100010001010010110110001101010010001111010010101010111000000001111001101" 487)
+
+let test9 _ = assert_equal 1 (minLength "1101" 1)
+
+let test10 _ = assert_equal 7 (minLength "100000011100001001001011010101110000000000011011010001111101110011101000101010010010100111100111001000010101000000010000000011010001011000101101001110101010100101110111100001001011100001010100100000110111100000111000111111010101000111100110111010100110101100110010000100000000111000001011111111111111100111011001001100101010101000100000110101100111110100100101110110000000000011111100010110111011000001001001110011101110011111010100110011000000000111011100010010101100101000010010100101101010100000000001001011001000010010011111110100110110011111101111111001101110110010011011011110001001100000010010010011101100011100100001111010100111001101000001001010100110110010101111111111111100010101000010001000" 11)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minLength" >::: [
+        
+  "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

smallest_substring_with_identical_characters_i/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minLength("000001",1), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.minLength("0000",2), 1)
+  }
+
+  test("test3") {
+    assertEquals(Main.minLength("111011101011001101110101111010001001010111111001010111011001110100010010101010101000111110010110000010000101010100111111001101100101110010100011111000111001100101001101100101111001011010110000001110111011001010101101110110100000010100001100011110111010011110101001010010010100011011110000101010010010101101000001110110100011111101011101000010001011101110000001110101110111110111011000111001101010110101001111101000111010101001101100010011111011010101011011110001011011000100011111111100100000111110010100010100000101000111100100001010000100011011001011100001100011010111001011010101001001101001111110000001010011100001000000100011011111110001011000101000001011111100111111010011100010111001110010000100100000011111000111000110001001101010001100111100000001010111000110011101010110010010100100000100",791), 1)
+  }
+
+  test("test4") {
+    assertEquals(Main.minLength("010001010100011010001010001011011101000001011110000100101001010000100001010111110101011001000100110011111111011101101100101110001111100011110101011011000001101001111110000010001100011110100011011111010101100010000010100000",168), 1)
+  }
+
+  test("test5") {
+    assertEquals(Main.minLength("0001001111010111010011001101110100000111011111110001001110111111100110011000110001111000000110100111100110010101000101001001100100001000001100010011001110000010110111001101100101011011100010101110011010100010110010100111111111010001011001101000011000100010110001111100100111011111000000001101101101110000111010000010010011001111101111111011110011010101101101011001100111110111011001000101000101011101000101001001000010110111101011100001100000001110010110000100101010110100110100010011101011111000001001111010110111010101001101110100111110000101000000011111101100000110001010000001100001100110000111000",255), 2)
+  }
+
+  test("test6") {
+    assertEquals(Main.minLength("110101001110100001010000010010111100110001011110010111011111111101010010101000010100001000010100100101110100111001010110010000001111011110111101111001110010111111001111100100110110100000101111111001101111110101011000001011110100100010001001010101001000001001001010000001110000010110000000000101111101010011110000011001100011111101000010010011100010100001001001001000010011100010110011100010011101100111100000010110010001111101011011000100111011010000011100000101111100101101100111001111001010101011111010001110000111011101001011010100010000110000011010101010001001110101",527), 1)
+  }
+
+  test("test7") {
+    assertEquals(Main.minLength("010000110000101101001100001101010000100000110100000010010111001111001001100010111100001001101111101101101011011110100010110101001111000001111010110100001101111001110100110000010001010101101110001110000101111000111111110001100110011011100001010000010000100010010010110111100100110101111011110011111100100111010010011000000001001110101000100110110110110011011111100111000010010100000010000101001111001111110100101010001111110001001100001010110000111000010000010001110101111010011000111101110001111010011001001100011011110110101100100010010011011110010100100101010010101100001011010001011011001100000011100100010111101101111111000000010110001010001010011011100000101011110000101011001100100001111100010001011010110000000000010110011",604), 1)
+  }
+
+  test("test8") {
+    assertEquals(Main.minLength("00101110001110010110011011100000010001001101001001000100111111001010110011000001110000001100011011100111101010110011111001100111110000011101011110010111010101010010001100111101000001001001111010010111001010101110010000010101100100011010000010110100010111111011110110101110110011010011011100001011101000110111100001110111101001111100100011001011000111100001101111110111000001011100010011111010110100010100000100111000100101101100010110100110110100011101010000111100010001010010110110001101010010001111010010101010111000000001111001101",487), 1)
+  }
+
+  test("test9") {
+    assertEquals(Main.minLength("1101",1), 1)
+  }
+
+  test("test10") {
+    assertEquals(Main.minLength("100000011100001001001011010101110000000000011011010001111101110011101000101010010010100111100111001000010101000000010000000011010001011000101101001110101010100101110111100001001011100001010100100000110111100000111000111111010101000111100110111010100110101100110010000100000000111000001011111111111111100111011001001100101010101000100000110101100111110100100101110110000000000011111100010110111011000001001001110011101110011111010100110011000000000111011100010010101100101000010010100101101010100000000001001011001000010010011111110100110110011111101111111001101110110010011011011110001001100000010010010011101100011100100001111010100111001101000001001010100110110010101111111111111100010101000010001000",11), 7)
+  }
+
+}

smallest_substring_with_identical_characters_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(2, minLength("000001", 1));
+}
+@Test
+public void test2() {
+    assertEquals(1, minLength("0000", 2));
+}
+
+}

snake_in_matrix/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, finalPositionOfSnake(2, new ArrayList<>(Arrays.asList("RIGHT","DOWN"))));
+}
+@Test
+public void test2() {
+    assertEquals(1, finalPositionOfSnake(3, new ArrayList<>(Arrays.asList("DOWN","RIGHT","UP"))));
+}
+
+}

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

solving_questions_with_brainpower/java_tests/Main.java

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

solving_questions_with_brainpower/meta.json

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

solving_questions_with_brainpower/ocaml_tests/main.ml

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

solving_questions_with_brainpower/scala_tests/MySuite.scala

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

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

sort_even_and_odd_indices_independently/java_tests/Main.java

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

sort_even_and_odd_indices_independently/meta.json

@@ -0,0 +1,1433 @@
+{
+    "id": 2283,
+    "name": "sort_even_and_odd_indices_independently",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/sort-even-and-odd-indices-independently/",
+    "date": "1643500800000",
+    "task_description": "You are given a **0-indexed** integer array `nums`. Rearrange the values of `nums` according to the following rules: Sort the values at **odd indices** of `nums` in **non-increasing** order. For example, if `nums = [4,**1**,2,**3**]` before this step, it becomes `[4,**3**,2,**1**]` after. The values at odd indices `1` and `3` are sorted in non-increasing order. Sort the values at **even indices** of `nums` in **non-decreasing** order. For example, if `nums = [**4**,1,**2**,3]` before this step, it becomes `[**2**,1,**4**,3]` after. The values at even indices `0` and `2` are sorted in non-decreasing order. Return _the array formed after rearranging the values of_ `nums`. **Example 1:** ``` **Input:** nums = [4,1,2,3] **Output:** [2,3,4,1] **Explanation:** First, we sort the values present at odd indices (1 and 3) in non-increasing order. So, nums changes from [4,**1**,2,**3**] to [4,**3**,2,**1**]. Next, we sort the values present at even indices (0 and 2) in non-decreasing order. So, nums changes from [**4**,1,**2**,3] to [**2**,3,**4**,1]. Thus, the array formed after rearranging the values is [2,3,4,1]. ``` **Example 2:** ``` **Input:** nums = [2,1] **Output:** [2,1] **Explanation:** Since there is exactly one odd index and one even index, no rearrangement of values takes place. The resultant array formed is [2,1], which is the same as the initial array. ``` **Constraints:** `1 <= nums.length <= 100` `1 <= nums[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [4,1,2,3]",
+            "output": "[2,3,4,1] "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,1]",
+            "output": "[2,1] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                1,
+                95,
+                2,
+                93,
+                6,
+                90,
+                15,
+                85,
+                15,
+                82,
+                21,
+                81,
+                26,
+                76,
+                34,
+                76,
+                35,
+                75,
+                38,
+                71,
+                38,
+                70,
+                38,
+                68,
+                39,
+                67,
+                40,
+                67,
+                40,
+                66,
+                43,
+                64,
+                45,
+                64,
+                45,
+                63,
+                45,
+                61,
+                46,
+                60,
+                47,
+                58,
+                47,
+                54,
+                48,
+                54,
+                50,
+                53,
+                50,
+                52,
+                53,
+                50,
+                53,
+                43,
+                54,
+                42,
+                55,
+                35,
+                55,
+                34,
+                56,
+                32,
+                57,
+                28,
+                58,
+                25,
+                60,
+                25,
+                60,
+                25,
+                63,
+                22,
+                70,
+                22,
+                77,
+                22,
+                77,
+                14,
+                78,
+                13,
+                80,
+                12,
+                83,
+                12,
+                84,
+                10,
+                88,
+                6,
+                88,
+                6,
+                90,
+                5,
+                92,
+                2,
+                95,
+                1,
+                97,
+                1,
+                100
+            ],
+            "output": [
+                1,
+                95,
+                2,
+                93,
+                6,
+                90,
+                15,
+                85,
+                15,
+                82,
+                21,
+                81,
+                26,
+                76,
+                34,
+                76,
+                35,
+                75,
+                38,
+                71,
+                38,
+                70,
+                38,
+                68,
+                39,
+                67,
+                40,
+                67,
+                40,
+                66,
+                43,
+                64,
+                45,
+                64,
+                45,
+                63,
+                45,
+                61,
+                46,
+                60,
+                47,
+                58,
+                47,
+                54,
+                48,
+                54,
+                50,
+                53,
+                50,
+                52,
+                53,
+                50,
+                53,
+                43,
+                54,
+                42,
+                55,
+                35,
+                55,
+                34,
+                56,
+                32,
+                57,
+                28,
+                58,
+                25,
+                60,
+                25,
+                60,
+                25,
+                63,
+                22,
+                70,
+                22,
+                77,
+                22,
+                77,
+                14,
+                78,
+                13,
+                80,
+                12,
+                83,
+                12,
+                84,
+                10,
+                88,
+                6,
+                88,
+                6,
+                90,
+                5,
+                92,
+                2,
+                95,
+                1,
+                97,
+                1,
+                100
+            ]
+        },
+        {
+            "input": [
+                12,
+                98,
+                23,
+                97,
+                29,
+                88,
+                38,
+                88,
+                40,
+                80,
+                54,
+                77,
+                55,
+                74,
+                57,
+                63,
+                60,
+                61,
+                61,
+                49,
+                62,
+                46,
+                74,
+                30,
+                80,
+                27,
+                82,
+                22,
+                84,
+                15,
+                92,
+                7,
+                94,
+                2,
+                96
+            ],
+            "output": [
+                12,
+                98,
+                23,
+                97,
+                29,
+                88,
+                38,
+                88,
+                40,
+                80,
+                54,
+                77,
+                55,
+                74,
+                57,
+                63,
+                60,
+                61,
+                61,
+                49,
+                62,
+                46,
+                74,
+                30,
+                80,
+                27,
+                82,
+                22,
+                84,
+                15,
+                92,
+                7,
+                94,
+                2,
+                96
+            ]
+        },
+        {
+            "input": [
+                2,
+                96,
+                3,
+                87,
+                4,
+                80,
+                9,
+                74,
+                12,
+                69,
+                15,
+                54,
+                15,
+                52,
+                17,
+                48,
+                18,
+                41,
+                29,
+                37,
+                30,
+                37,
+                32,
+                37,
+                35,
+                36,
+                55,
+                25,
+                56,
+                21,
+                56,
+                20,
+                68,
+                18,
+                69,
+                16,
+                73,
+                10,
+                87,
+                9,
+                96
+            ],
+            "output": [
+                2,
+                96,
+                3,
+                87,
+                4,
+                80,
+                9,
+                74,
+                12,
+                69,
+                15,
+                54,
+                15,
+                52,
+                17,
+                48,
+                18,
+                41,
+                29,
+                37,
+                30,
+                37,
+                32,
+                37,
+                35,
+                36,
+                55,
+                25,
+                56,
+                21,
+                56,
+                20,
+                68,
+                18,
+                69,
+                16,
+                73,
+                10,
+                87,
+                9,
+                96
+            ]
+        },
+        {
+            "input": [
+                1,
+                93,
+                19,
+                91,
+                23,
+                82,
+                36,
+                74,
+                37,
+                69,
+                45,
+                69,
+                50,
+                66,
+                59,
+                64,
+                60,
+                63,
+                62,
+                61,
+                62,
+                54,
+                64,
+                49,
+                66,
+                47,
+                73,
+                44,
+                74,
+                40,
+                83,
+                26,
+                84,
+                24,
+                87
+            ],
+            "output": [
+                1,
+                93,
+                19,
+                91,
+                23,
+                82,
+                36,
+                74,
+                37,
+                69,
+                45,
+                69,
+                50,
+                66,
+                59,
+                64,
+                60,
+                63,
+                62,
+                61,
+                62,
+                54,
+                64,
+                49,
+                66,
+                47,
+                73,
+                44,
+                74,
+                40,
+                83,
+                26,
+                84,
+                24,
+                87
+            ]
+        },
+        {
+            "input": [
+                2,
+                84,
+                4,
+                80,
+                18,
+                79,
+                20,
+                78,
+                32,
+                78,
+                35,
+                77,
+                37,
+                69,
+                38,
+                69,
+                43,
+                67,
+                45,
+                63,
+                46,
+                63,
+                50,
+                55,
+                51,
+                38,
+                57,
+                32,
+                61,
+                29,
+                63,
+                28,
+                68,
+                20,
+                70,
+                18,
+                72,
+                18,
+                79,
+                13,
+                79,
+                12,
+                91,
+                11,
+                95,
+                2
+            ],
+            "output": [
+                2,
+                84,
+                4,
+                80,
+                18,
+                79,
+                20,
+                78,
+                32,
+                78,
+                35,
+                77,
+                37,
+                69,
+                38,
+                69,
+                43,
+                67,
+                45,
+                63,
+                46,
+                63,
+                50,
+                55,
+                51,
+                38,
+                57,
+                32,
+                61,
+                29,
+                63,
+                28,
+                68,
+                20,
+                70,
+                18,
+                72,
+                18,
+                79,
+                13,
+                79,
+                12,
+                91,
+                11,
+                95,
+                2
+            ]
+        },
+        {
+            "input": [
+                5,
+                95,
+                6,
+                93,
+                12,
+                89,
+                13,
+                83,
+                16,
+                80,
+                17,
+                76,
+                17,
+                73,
+                20,
+                72,
+                20,
+                70,
+                22,
+                69,
+                22,
+                69,
+                24,
+                69,
+                28,
+                68,
+                30,
+                64,
+                30,
+                64,
+                33,
+                63,
+                34,
+                60,
+                35,
+                59,
+                40,
+                58,
+                46,
+                57,
+                50,
+                54,
+                50,
+                51,
+                54,
+                51,
+                59,
+                47,
+                60,
+                45,
+                66,
+                39,
+                72,
+                36,
+                75,
+                28,
+                77,
+                27,
+                82,
+                25,
+                83,
+                25,
+                85,
+                25,
+                87,
+                23,
+                88,
+                22,
+                90,
+                17,
+                91,
+                14,
+                91,
+                12,
+                95,
+                9,
+                95,
+                7,
+                100,
+                6
+            ],
+            "output": [
+                5,
+                95,
+                6,
+                93,
+                12,
+                89,
+                13,
+                83,
+                16,
+                80,
+                17,
+                76,
+                17,
+                73,
+                20,
+                72,
+                20,
+                70,
+                22,
+                69,
+                22,
+                69,
+                24,
+                69,
+                28,
+                68,
+                30,
+                64,
+                30,
+                64,
+                33,
+                63,
+                34,
+                60,
+                35,
+                59,
+                40,
+                58,
+                46,
+                57,
+                50,
+                54,
+                50,
+                51,
+                54,
+                51,
+                59,
+                47,
+                60,
+                45,
+                66,
+                39,
+                72,
+                36,
+                75,
+                28,
+                77,
+                27,
+                82,
+                25,
+                83,
+                25,
+                85,
+                25,
+                87,
+                23,
+                88,
+                22,
+                90,
+                17,
+                91,
+                14,
+                91,
+                12,
+                95,
+                9,
+                95,
+                7,
+                100,
+                6
+            ]
+        },
+        {
+            "input": [
+                1,
+                100,
+                4,
+                97,
+                4,
+                94,
+                12,
+                94,
+                15,
+                91,
+                19,
+                88,
+                20,
+                87,
+                26,
+                87,
+                26,
+                86,
+                28,
+                83,
+                29,
+                83,
+                30,
+                78,
+                34,
+                77,
+                35,
+                69,
+                49,
+                66,
+                51,
+                65,
+                53,
+                63,
+                62,
+                59,
+                66,
+                58,
+                67,
+                56,
+                70,
+                54,
+                72,
+                53,
+                72,
+                41,
+                72,
+                36,
+                73,
+                31,
+                74,
+                30,
+                77,
+                30,
+                82,
+                29,
+                84,
+                26,
+                95,
+                22,
+                95,
+                21,
+                96,
+                21,
+                97,
+                12,
+                98,
+                9,
+                98,
+                5,
+                99,
+                3,
+                99
+            ],
+            "output": [
+                1,
+                100,
+                4,
+                97,
+                4,
+                94,
+                12,
+                94,
+                15,
+                91,
+                19,
+                88,
+                20,
+                87,
+                26,
+                87,
+                26,
+                86,
+                28,
+                83,
+                29,
+                83,
+                30,
+                78,
+                34,
+                77,
+                35,
+                69,
+                49,
+                66,
+                51,
+                65,
+                53,
+                63,
+                62,
+                59,
+                66,
+                58,
+                67,
+                56,
+                70,
+                54,
+                72,
+                53,
+                72,
+                41,
+                72,
+                36,
+                73,
+                31,
+                74,
+                30,
+                77,
+                30,
+                82,
+                29,
+                84,
+                26,
+                95,
+                22,
+                95,
+                21,
+                96,
+                21,
+                97,
+                12,
+                98,
+                9,
+                98,
+                5,
+                99,
+                3,
+                99
+            ]
+        },
+        {
+            "input": [
+                2,
+                94,
+                3,
+                93,
+                4,
+                87,
+                5,
+                86,
+                10,
+                85,
+                12,
+                84,
+                13,
+                84,
+                14,
+                83,
+                14,
+                82,
+                19,
+                81,
+                19,
+                79,
+                24,
+                78,
+                26,
+                77,
+                27,
+                77,
+                28,
+                76,
+                30,
+                75,
+                31,
+                69,
+                31,
+                68,
+                33,
+                62,
+                36,
+                61,
+                37,
+                58,
+                40,
+                57,
+                44,
+                56,
+                48,
+                54,
+                48,
+                54,
+                49,
+                50,
+                57,
+                45,
+                57,
+                44,
+                57,
+                42,
+                59,
+                40,
+                59,
+                37,
+                64,
+                37,
+                67,
+                34,
+                72,
+                31,
+                76,
+                30,
+                78,
+                22,
+                78,
+                18,
+                80,
+                15,
+                80,
+                13,
+                80,
+                9,
+                81,
+                9,
+                86,
+                5,
+                90,
+                5,
+                92,
+                3,
+                100,
+                1
+            ],
+            "output": [
+                2,
+                94,
+                3,
+                93,
+                4,
+                87,
+                5,
+                86,
+                10,
+                85,
+                12,
+                84,
+                13,
+                84,
+                14,
+                83,
+                14,
+                82,
+                19,
+                81,
+                19,
+                79,
+                24,
+                78,
+                26,
+                77,
+                27,
+                77,
+                28,
+                76,
+                30,
+                75,
+                31,
+                69,
+                31,
+                68,
+                33,
+                62,
+                36,
+                61,
+                37,
+                58,
+                40,
+                57,
+                44,
+                56,
+                48,
+                54,
+                48,
+                54,
+                49,
+                50,
+                57,
+                45,
+                57,
+                44,
+                57,
+                42,
+                59,
+                40,
+                59,
+                37,
+                64,
+                37,
+                67,
+                34,
+                72,
+                31,
+                76,
+                30,
+                78,
+                22,
+                78,
+                18,
+                80,
+                15,
+                80,
+                13,
+                80,
+                9,
+                81,
+                9,
+                86,
+                5,
+                90,
+                5,
+                92,
+                3,
+                100,
+                1
+            ]
+        },
+        {
+            "input": [
+                1,
+                96,
+                5,
+                96,
+                8,
+                95,
+                9,
+                89,
+                15,
+                87,
+                16,
+                86,
+                17,
+                85,
+                17,
+                85,
+                21,
+                83,
+                22,
+                81,
+                27,
+                81,
+                27,
+                79,
+                28,
+                79,
+                29,
+                67,
+                32,
+                67,
+                34,
+                66,
+                35,
+                63,
+                36,
+                63,
+                40,
+                63,
+                45,
+                61,
+                52,
+                59,
+                54,
+                58,
+                54,
+                55,
+                57,
+                44,
+                58,
+                41,
+                61,
+                40,
+                67,
+                38,
+                67,
+                33,
+                67,
+                29,
+                67,
+                27,
+                68,
+                27,
+                74,
+                27,
+                76,
+                21,
+                78,
+                19,
+                85,
+                19,
+                85,
+                16,
+                86,
+                11,
+                89,
+                7,
+                90,
+                6,
+                96,
+                3,
+                99,
+                2,
+                99,
+                2,
+                100,
+                2,
+                100
+            ],
+            "output": [
+                1,
+                96,
+                5,
+                96,
+                8,
+                95,
+                9,
+                89,
+                15,
+                87,
+                16,
+                86,
+                17,
+                85,
+                17,
+                85,
+                21,
+                83,
+                22,
+                81,
+                27,
+                81,
+                27,
+                79,
+                28,
+                79,
+                29,
+                67,
+                32,
+                67,
+                34,
+                66,
+                35,
+                63,
+                36,
+                63,
+                40,
+                63,
+                45,
+                61,
+                52,
+                59,
+                54,
+                58,
+                54,
+                55,
+                57,
+                44,
+                58,
+                41,
+                61,
+                40,
+                67,
+                38,
+                67,
+                33,
+                67,
+                29,
+                67,
+                27,
+                68,
+                27,
+                74,
+                27,
+                76,
+                21,
+                78,
+                19,
+                85,
+                19,
+                85,
+                16,
+                86,
+                11,
+                89,
+                7,
+                90,
+                6,
+                96,
+                3,
+                99,
+                2,
+                99,
+                2,
+                100,
+                2,
+                100
+            ]
+        },
+        {
+            "input": [
+                2,
+                100,
+                5,
+                97,
+                7,
+                93,
+                11,
+                91,
+                16,
+                88,
+                19,
+                86,
+                21,
+                86,
+                22,
+                84,
+                23,
+                82,
+                23,
+                79,
+                24,
+                78,
+                24,
+                75,
+                25,
+                73,
+                28,
+                70,
+                31,
+                70,
+                31,
+                66,
+                38,
+                65,
+                42,
+                65,
+                44,
+                64,
+                46,
+                61,
+                57,
+                59,
+                57,
+                56,
+                57,
+                56,
+                57,
+                54,
+                57,
+                46,
+                61,
+                46,
+                64,
+                45,
+                64,
+                43,
+                64,
+                39,
+                65,
+                39,
+                71,
+                30,
+                71,
+                30,
+                73,
+                26,
+                78,
+                26,
+                79,
+                26,
+                79,
+                24,
+                82,
+                23,
+                86,
+                21,
+                89,
+                19,
+                90,
+                18,
+                91,
+                12,
+                96,
+                7,
+                99,
+                5,
+                100
+            ],
+            "output": [
+                2,
+                100,
+                5,
+                97,
+                7,
+                93,
+                11,
+                91,
+                16,
+                88,
+                19,
+                86,
+                21,
+                86,
+                22,
+                84,
+                23,
+                82,
+                23,
+                79,
+                24,
+                78,
+                24,
+                75,
+                25,
+                73,
+                28,
+                70,
+                31,
+                70,
+                31,
+                66,
+                38,
+                65,
+                42,
+                65,
+                44,
+                64,
+                46,
+                61,
+                57,
+                59,
+                57,
+                56,
+                57,
+                56,
+                57,
+                54,
+                57,
+                46,
+                61,
+                46,
+                64,
+                45,
+                64,
+                43,
+                64,
+                39,
+                65,
+                39,
+                71,
+                30,
+                71,
+                30,
+                73,
+                26,
+                78,
+                26,
+                79,
+                26,
+                79,
+                24,
+                82,
+                23,
+                86,
+                21,
+                89,
+                19,
+                90,
+                18,
+                91,
+                12,
+                96,
+                7,
+                99,
+                5,
+                100
+            ]
+        }
+    ],
+    "haskell_template": "sortEvenOdd :: [Int] -> [Int]\nsortEvenOdd nums ",
+    "ocaml_template": "let sortEvenOdd (nums: int list) : int list =  ",
+    "scala_template": "def sortEvenOdd(nums: List[Int]): List[Int] = { \n    \n}",
+    "java_template": "public static List<Integer> sortEvenOdd(List<Integer> nums) {\n\n}",
+    "python_template": "class Solution(object):\n    def sortEvenOdd(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

sort_even_and_odd_indices_independently/ocaml_tests/main.ml

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

sort_even_and_odd_indices_independently/scala_tests/MySuite.scala

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

sort_matrix_by_diagonals/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+sortMatrix :: [[Int]] -> [[Int]]
+sortMatrix grid = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (sortMatrix [[1,7,3],[9,8,2],[4,5,6]])," [[8,2,3],[9,6,7],[4,5,1]] (sortMatrix [[1,7,3],[9,8,2],[4,5,6]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (sortMatrix [[0,1],[1,2]])," [[2,1],[1,0]] (sortMatrix [[0,1],[1,2]]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (sortMatrix [[1]])," [[1]] (sortMatrix [[1]]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (sortMatrix [[73413, 89675], [64042, 3426]])," [[73413,89675],[64042,3426]] (sortMatrix [[73413, 89675], [64042, 3426]]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (sortMatrix [[93534, ( -60538), 1100, ( -29080)], [73904, 73681, ( -42006), 58036], [-54576, 43994, ( -44130), ( -9191)], [35790, ( -98159), ( -43670), ( -71219)]])," [[93534,(-60538),1100,(-29080)],[73904,73681,(-42006),58036],[-54576,43994,(-44130),(-9191)],[35790,(-98159),(-43670),(-71219)]] (sortMatrix [[93534, -60538, 1100, -29080], [73904, 73681, -42006, 58036], [-54576, 43994, -44130, -9191], [35790, -98159, -43670, -71219]]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (sortMatrix [[59508, ( -30375), 53549], [76794, ( -45364), 68655], [59076, ( -95778), ( -72798)]])," [[59508,(-30375),53549],[76794,(-45364),68655],[59076,(-95778),(-72798)]] (sortMatrix [[59508, -30375, 53549], [76794, -45364, 68655], [59076, -95778, -72798]]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (sortMatrix [[70237, ( -28097), ( -75510), ( -93714), ( -13815), ( -81959), ( -59992), ( -43975), ( -70863)], [40288, 50377, ( -15278), ( -54865), ( -78871), 38194, ( -64139), ( -23739), 83299], [75198, 26853, 45303, 17073, ( -52554), ( -69846), 41075, ( -10375), 61633], [71858, 25443, ( -12504), 17141, 46172, ( -23439), 16688, 46570, 24044], [59184, 60566, 13801, ( -28186), ( -2540), 59190, ( -3452), 81433, 67105], [90462, 37330, 57191, ( -30681), ( -44432), ( -22472), 59534, 27280, 83274], [99727, 15152, ( -37289), 36698, ( -39528), ( -47895), ( -50758), 75176, 62571], [83565, ( -16059), ( -17953), ( -40686), 35575, ( -41645), ( -74717), ( -80703), 78122], [12632, 65938, ( -48947), ( -75351), ( -84100), ( -18388), ( -96082), ( -97690), ( -92412)]])," [[70237,(-28097),(-75510),(-93714),(-13815),(-81959),(-59992),(-43975),(-70863)],[40288,50377,(-15278),(-54865),(-78871),38194,(-64139),(-23739),83299],[75198,26853,45303,17073,(-52554),(-69846),41075,(-10375),61633],[71858,25443,(-12504),17141,46172,(-23439),16688,46570,24044],[59184,60566,13801,(-28186),(-2540),59190,(-3452),81433,67105],[90462,37330,57191,(-30681),(-44432),(-22472),59534,27280,83274],[99727,15152,(-37289),36698,(-39528),(-47895),(-50758),75176,62571],[83565,(-16059),(-17953),(-40686),35575,(-41645),(-74717),(-80703),78122],[12632,65938,(-48947),(-75351),(-84100),(-18388),(-96082),(-97690),(-92412)]] (sortMatrix [[70237, -28097, -75510, -93714, -13815, -81959, -59992, -43975, -70863], [40288, 50377, -15278, -54865, -78871, 38194, -64139, -23739, 83299], [75198, 26853, 45303, 17073, -52554, -69846, 41075, -10375, 61633], [71858, 25443, -12504, 17141, 46172, -23439, 16688, 46570, 24044], [59184, 60566, 13801, -28186, -2540, 59190, -3452, 81433, 67105], [90462, 37330, 57191, -30681, -44432, -22472, 59534, 27280, 83274], [99727, 15152, -37289, 36698, -39528, -47895, -50758, 75176, 62571], [83565, -16059, -17953, -40686, 35575, -41645, -74717, -80703, 78122], [12632, 65938, -48947, -75351, -84100, -18388, -96082, -97690, -92412]]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (sortMatrix [[93680, ( -89587), ( -96793), ( -88056), ( -67363), ( -57242), ( -67539), ( -78121), ( -55829), ( -57391)], [70507, 28181, ( -65217), ( -76332), ( -42429), ( -38150), ( -48555), ( -2009), ( -63212), 39636], [69116, 50346, 23408, ( -40122), ( -75329), 29472, ( -21407), ( -29091), ( -468), 29793], [64817, 39118, 38117, 4200, 31191, ( -62081), 42875, 4261, 43215, 1967], [73153, 49917, 23947, 32443, ( -25788), 51430, ( -30848), 66550, 62937, 91163], [48378, 66018, 37406, ( -4699), 21998, ( -41176), 78126, 19189, 79570, 81497], [-23104, 19536, 53987, 29462, ( -10253), 16954, ( -47341), 80533, 52244, 81496], [66168, ( -30888), ( -18525), 40048, 23718, ( -52041), ( -14933), ( -49448), 90366, 99859], [55807, 60419, ( -45089), ( -30668), 8678, ( -10026), ( -56978), ( -16041), ( -78687), 91900], [-31370, ( -47928), ( -12268), ( -84613), ( -76766), ( -42972), ( -74771), ( -88090), ( -58183), ( -79213)]])," [[93680,(-89587),(-96793),(-88056),(-67363),(-57242),(-67539),(-78121),(-55829),(-57391)],[70507,28181,(-65217),(-76332),(-42429),(-38150),(-48555),(-2009),(-63212),39636],[69116,50346,23408,(-40122),(-75329),29472,(-21407),(-29091),(-468),29793],[64817,39118,38117,4200,31191,(-62081),42875,4261,43215,1967],[73153,49917,23947,32443,(-25788),51430,(-30848),66550,62937,91163],[48378,66018,37406,(-4699),21998,(-41176),78126,19189,79570,81497],[-23104,19536,53987,29462,(-10253),16954,(-47341),80533,52244,81496],[66168,(-30888),(-18525),40048,23718,(-52041),(-14933),(-49448),90366,99859],[55807,60419,(-45089),(-30668),8678,(-10026),(-56978),(-16041),(-78687),91900],[-31370,(-47928),(-12268),(-84613),(-76766),(-42972),(-74771),(-88090),(-58183),(-79213)]] (sortMatrix [[93680, -89587, -96793, -88056, -67363, -57242, -67539, -78121, -55829, -57391], [70507, 28181, -65217, -76332, -42429, -38150, -48555, -2009, -63212, 39636], [69116, 50346, 23408, -40122, -75329, 29472, -21407, -29091, -468, 29793], [64817, 39118, 38117, 4200, 31191, -62081, 42875, 4261, 43215, 1967], [73153, 49917, 23947, 32443, -25788, 51430, -30848, 66550, 62937, 91163], [48378, 66018, 37406, -4699, 21998, -41176, 78126, 19189, 79570, 81497], [-23104, 19536, 53987, 29462, -10253, 16954, -47341, 80533, 52244, 81496], [66168, -30888, -18525, 40048, 23718, -52041, -14933, -49448, 90366, 99859], [55807, 60419, -45089, -30668, 8678, -10026, -56978, -16041, -78687, 91900], [-31370, -47928, -12268, -84613, -76766, -42972, -74771, -88090, -58183, -79213]]))
+
+
+-- 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

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

sort_matrix_by_diagonals/meta.json

@@ -0,0 +1,594 @@
+{
+    "id": 3748,
+    "name": "sort_matrix_by_diagonals",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/sort-matrix-by-diagonals/",
+    "date": "2025-02-02 00:00:00",
+    "task_description": "You are given an `n x n` square matrix of integers `grid`. Return the matrix such that: The diagonals in the **bottom-left triangle** (including the middle diagonal) are sorted in **non-increasing order**. The diagonals in the **top-right triangle** are sorted in **non-decreasing order**. **Example 1:** **Input:** grid = [[1,7,3],[9,8,2],[4,5,6]] **Output:** [[8,2,3],[9,6,7],[4,5,1]] **Explanation:** The diagonals with a black arrow (bottom-left triangle) should be sorted in non-increasing order: `[1, 8, 6]` becomes `[8, 6, 1]`. `[9, 5]` and `[4]` remain unchanged. The diagonals with a blue arrow (top-right triangle) should be sorted in non-decreasing order: `[7, 2]` becomes `[2, 7]`. `[3]` remains unchanged. **Example 2:** **Input:** grid = [[0,1],[1,2]] **Output:** [[2,1],[1,0]] **Explanation:** The diagonals with a black arrow must be non-increasing, so `[0, 2]` is changed to `[2, 0]`. The other diagonals are already in the correct order. **Example 3:** **Input:** grid = [[1]] **Output:** [[1]] **Explanation:** Diagonals with exactly one element are already in order, so no changes are needed. **Constraints:** `grid.length == grid[i].length == n` `1 <= n <= 10` `-105 <= grid[i][j] <= 105`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "grid = [[1,7,3],[9,8,2],[4,5,6]]",
+            "output": "[[8,2,3],[9,6,7],[4,5,1]] "
+        },
+        {
+            "label": "Example 2",
+            "input": "grid = [[0,1],[1,2]]",
+            "output": "[[2,1],[1,0]] "
+        },
+        {
+            "label": "Example 3",
+            "input": "grid = [[1]]",
+            "output": "[[1]] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    73413,
+                    89675
+                ],
+                [
+                    64042,
+                    3426
+                ]
+            ],
+            "output": [
+                [
+                    73413,
+                    89675
+                ],
+                [
+                    64042,
+                    3426
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    93534,
+                    -60538,
+                    1100,
+                    -29080
+                ],
+                [
+                    73904,
+                    73681,
+                    -42006,
+                    58036
+                ],
+                [
+                    -54576,
+                    43994,
+                    -44130,
+                    -9191
+                ],
+                [
+                    35790,
+                    -98159,
+                    -43670,
+                    -71219
+                ]
+            ],
+            "output": [
+                [
+                    93534,
+                    -60538,
+                    1100,
+                    -29080
+                ],
+                [
+                    73904,
+                    73681,
+                    -42006,
+                    58036
+                ],
+                [
+                    -54576,
+                    43994,
+                    -44130,
+                    -9191
+                ],
+                [
+                    35790,
+                    -98159,
+                    -43670,
+                    -71219
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    59508,
+                    -30375,
+                    53549
+                ],
+                [
+                    76794,
+                    -45364,
+                    68655
+                ],
+                [
+                    59076,
+                    -95778,
+                    -72798
+                ]
+            ],
+            "output": [
+                [
+                    59508,
+                    -30375,
+                    53549
+                ],
+                [
+                    76794,
+                    -45364,
+                    68655
+                ],
+                [
+                    59076,
+                    -95778,
+                    -72798
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    70237,
+                    -28097,
+                    -75510,
+                    -93714,
+                    -13815,
+                    -81959,
+                    -59992,
+                    -43975,
+                    -70863
+                ],
+                [
+                    40288,
+                    50377,
+                    -15278,
+                    -54865,
+                    -78871,
+                    38194,
+                    -64139,
+                    -23739,
+                    83299
+                ],
+                [
+                    75198,
+                    26853,
+                    45303,
+                    17073,
+                    -52554,
+                    -69846,
+                    41075,
+                    -10375,
+                    61633
+                ],
+                [
+                    71858,
+                    25443,
+                    -12504,
+                    17141,
+                    46172,
+                    -23439,
+                    16688,
+                    46570,
+                    24044
+                ],
+                [
+                    59184,
+                    60566,
+                    13801,
+                    -28186,
+                    -2540,
+                    59190,
+                    -3452,
+                    81433,
+                    67105
+                ],
+                [
+                    90462,
+                    37330,
+                    57191,
+                    -30681,
+                    -44432,
+                    -22472,
+                    59534,
+                    27280,
+                    83274
+                ],
+                [
+                    99727,
+                    15152,
+                    -37289,
+                    36698,
+                    -39528,
+                    -47895,
+                    -50758,
+                    75176,
+                    62571
+                ],
+                [
+                    83565,
+                    -16059,
+                    -17953,
+                    -40686,
+                    35575,
+                    -41645,
+                    -74717,
+                    -80703,
+                    78122
+                ],
+                [
+                    12632,
+                    65938,
+                    -48947,
+                    -75351,
+                    -84100,
+                    -18388,
+                    -96082,
+                    -97690,
+                    -92412
+                ]
+            ],
+            "output": [
+                [
+                    70237,
+                    -28097,
+                    -75510,
+                    -93714,
+                    -13815,
+                    -81959,
+                    -59992,
+                    -43975,
+                    -70863
+                ],
+                [
+                    40288,
+                    50377,
+                    -15278,
+                    -54865,
+                    -78871,
+                    38194,
+                    -64139,
+                    -23739,
+                    83299
+                ],
+                [
+                    75198,
+                    26853,
+                    45303,
+                    17073,
+                    -52554,
+                    -69846,
+                    41075,
+                    -10375,
+                    61633
+                ],
+                [
+                    71858,
+                    25443,
+                    -12504,
+                    17141,
+                    46172,
+                    -23439,
+                    16688,
+                    46570,
+                    24044
+                ],
+                [
+                    59184,
+                    60566,
+                    13801,
+                    -28186,
+                    -2540,
+                    59190,
+                    -3452,
+                    81433,
+                    67105
+                ],
+                [
+                    90462,
+                    37330,
+                    57191,
+                    -30681,
+                    -44432,
+                    -22472,
+                    59534,
+                    27280,
+                    83274
+                ],
+                [
+                    99727,
+                    15152,
+                    -37289,
+                    36698,
+                    -39528,
+                    -47895,
+                    -50758,
+                    75176,
+                    62571
+                ],
+                [
+                    83565,
+                    -16059,
+                    -17953,
+                    -40686,
+                    35575,
+                    -41645,
+                    -74717,
+                    -80703,
+                    78122
+                ],
+                [
+                    12632,
+                    65938,
+                    -48947,
+                    -75351,
+                    -84100,
+                    -18388,
+                    -96082,
+                    -97690,
+                    -92412
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    93680,
+                    -89587,
+                    -96793,
+                    -88056,
+                    -67363,
+                    -57242,
+                    -67539,
+                    -78121,
+                    -55829,
+                    -57391
+                ],
+                [
+                    70507,
+                    28181,
+                    -65217,
+                    -76332,
+                    -42429,
+                    -38150,
+                    -48555,
+                    -2009,
+                    -63212,
+                    39636
+                ],
+                [
+                    69116,
+                    50346,
+                    23408,
+                    -40122,
+                    -75329,
+                    29472,
+                    -21407,
+                    -29091,
+                    -468,
+                    29793
+                ],
+                [
+                    64817,
+                    39118,
+                    38117,
+                    4200,
+                    31191,
+                    -62081,
+                    42875,
+                    4261,
+                    43215,
+                    1967
+                ],
+                [
+                    73153,
+                    49917,
+                    23947,
+                    32443,
+                    -25788,
+                    51430,
+                    -30848,
+                    66550,
+                    62937,
+                    91163
+                ],
+                [
+                    48378,
+                    66018,
+                    37406,
+                    -4699,
+                    21998,
+                    -41176,
+                    78126,
+                    19189,
+                    79570,
+                    81497
+                ],
+                [
+                    -23104,
+                    19536,
+                    53987,
+                    29462,
+                    -10253,
+                    16954,
+                    -47341,
+                    80533,
+                    52244,
+                    81496
+                ],
+                [
+                    66168,
+                    -30888,
+                    -18525,
+                    40048,
+                    23718,
+                    -52041,
+                    -14933,
+                    -49448,
+                    90366,
+                    99859
+                ],
+                [
+                    55807,
+                    60419,
+                    -45089,
+                    -30668,
+                    8678,
+                    -10026,
+                    -56978,
+                    -16041,
+                    -78687,
+                    91900
+                ],
+                [
+                    -31370,
+                    -47928,
+                    -12268,
+                    -84613,
+                    -76766,
+                    -42972,
+                    -74771,
+                    -88090,
+                    -58183,
+                    -79213
+                ]
+            ],
+            "output": [
+                [
+                    93680,
+                    -89587,
+                    -96793,
+                    -88056,
+                    -67363,
+                    -57242,
+                    -67539,
+                    -78121,
+                    -55829,
+                    -57391
+                ],
+                [
+                    70507,
+                    28181,
+                    -65217,
+                    -76332,
+                    -42429,
+                    -38150,
+                    -48555,
+                    -2009,
+                    -63212,
+                    39636
+                ],
+                [
+                    69116,
+                    50346,
+                    23408,
+                    -40122,
+                    -75329,
+                    29472,
+                    -21407,
+                    -29091,
+                    -468,
+                    29793
+                ],
+                [
+                    64817,
+                    39118,
+                    38117,
+                    4200,
+                    31191,
+                    -62081,
+                    42875,
+                    4261,
+                    43215,
+                    1967
+                ],
+                [
+                    73153,
+                    49917,
+                    23947,
+                    32443,
+                    -25788,
+                    51430,
+                    -30848,
+                    66550,
+                    62937,
+                    91163
+                ],
+                [
+                    48378,
+                    66018,
+                    37406,
+                    -4699,
+                    21998,
+                    -41176,
+                    78126,
+                    19189,
+                    79570,
+                    81497
+                ],
+                [
+                    -23104,
+                    19536,
+                    53987,
+                    29462,
+                    -10253,
+                    16954,
+                    -47341,
+                    80533,
+                    52244,
+                    81496
+                ],
+                [
+                    66168,
+                    -30888,
+                    -18525,
+                    40048,
+                    23718,
+                    -52041,
+                    -14933,
+                    -49448,
+                    90366,
+                    99859
+                ],
+                [
+                    55807,
+                    60419,
+                    -45089,
+                    -30668,
+                    8678,
+                    -10026,
+                    -56978,
+                    -16041,
+                    -78687,
+                    91900
+                ],
+                [
+                    -31370,
+                    -47928,
+                    -12268,
+                    -84613,
+                    -76766,
+                    -42972,
+                    -74771,
+                    -88090,
+                    -58183,
+                    -79213
+                ]
+            ]
+        }
+    ],
+    "haskell_template": "sortMatrix :: [[Int]] -> [[Int]]\nsortMatrix grid ",
+    "ocaml_template": "let sortMatrix (grid: int list list) : int list list =  ",
+    "scala_template": "def sortMatrix(grid: List[List[Int]]): List[List[Int]] = { \n    \n}",
+    "java_template": "class Solution {\n    public int[][] sortMatrix(int[][] grid) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def sortMatrix(self, grid):\n        \"\"\"\n        :type grid: List[List[int]]\n        :rtype: List[List[int]]\n        \"\"\"\n        "
+}

sort_matrix_by_diagonals/ocaml_tests/main.ml

@@ -0,0 +1,45 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let sortMatrix (grid: int list list) : int list list =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal [[8;2;3];[9;6;7];[4;5;1]] (sortMatrix [[1;7;3];[9;8;2];[4;5;6]])
+
+let test2 _ = assert_equal [[2;1];[1;0]] (sortMatrix [[0;1];[1;2]])
+
+let test3 _ = assert_equal [[1]] (sortMatrix [[1]])
+
+let test4 _ = assert_equal [[1]] (sortMatrix [[73413; 89675]; [64042; 3426]])
+
+let test5 _ = assert_equal [[1]] (sortMatrix [[93534; -60538; 1100; -29080]; [73904; 73681; -42006; 58036]; [-54576; 43994; -44130; -9191]; [35790; -98159; -43670; -71219]])
+
+let test6 _ = assert_equal [[1]] (sortMatrix [[59508; -30375; 53549]; [76794; -45364; 68655]; [59076; -95778; -72798]])
+
+let test7 _ = assert_equal [[1]] (sortMatrix [[70237; -28097; -75510; -93714; -13815; -81959; -59992; -43975; -70863]; [40288; 50377; -15278; -54865; -78871; 38194; -64139; -23739; 83299]; [75198; 26853; 45303; 17073; -52554; -69846; 41075; -10375; 61633]; [71858; 25443; -12504; 17141; 46172; -23439; 16688; 46570; 24044]; [59184; 60566; 13801; -28186; -2540; 59190; -3452; 81433; 67105]; [90462; 37330; 57191; -30681; -44432; -22472; 59534; 27280; 83274]; [99727; 15152; -37289; 36698; -39528; -47895; -50758; 75176; 62571]; [83565; -16059; -17953; -40686; 35575; -41645; -74717; -80703; 78122]; [12632; 65938; -48947; -75351; -84100; -18388; -96082; -97690; -92412]])
+
+let test8 _ = assert_equal [[1]] (sortMatrix [[93680; -89587; -96793; -88056; -67363; -57242; -67539; -78121; -55829; -57391]; [70507; 28181; -65217; -76332; -42429; -38150; -48555; -2009; -63212; 39636]; [69116; 50346; 23408; -40122; -75329; 29472; -21407; -29091; -468; 29793]; [64817; 39118; 38117; 4200; 31191; -62081; 42875; 4261; 43215; 1967]; [73153; 49917; 23947; 32443; -25788; 51430; -30848; 66550; 62937; 91163]; [48378; 66018; 37406; -4699; 21998; -41176; 78126; 19189; 79570; 81497]; [-23104; 19536; 53987; 29462; -10253; 16954; -47341; 80533; 52244; 81496]; [66168; -30888; -18525; 40048; 23718; -52041; -14933; -49448; 90366; 99859]; [55807; 60419; -45089; -30668; 8678; -10026; -56978; -16041; -78687; 91900]; [-31370; -47928; -12268; -84613; -76766; -42972; -74771; -88090; -58183; -79213]])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for sortMatrix" >::: [
+        
+  "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

sort_matrix_by_diagonals/scala_tests/MySuite.scala

@@ -0,0 +1,36 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.sortMatrix(List(List(1,7,3),List(9,8,2),List(4,5,6))), List(List(8,2,3),List(9,6,7),List(4,5,1)))
+  }
+
+  test("test2") {
+    assertEquals(Main.sortMatrix(List(List(0,1),List(1,2))), List(List(2,1),List(1,0)))
+  }
+
+  test("test3") {
+    assertEquals(Main.sortMatrix(List(List(1))), List(List(1)))
+  }
+
+  test("test4") {
+    assertEquals(Main.sortMatrix(List(73413, 89675),List(64042, 3426)), List(List(73413,89675),List(64042,3426)))
+  }
+
+  test("test5") {
+    assertEquals(Main.sortMatrix(List(93534, -60538, 1100, -29080),List(73904, 73681, -42006, 58036),List(-54576, 43994, -44130, -9191),List(35790, -98159, -43670, -71219)), List(List(93534,-60538,1100,-29080),List(73904,73681,-42006,58036),List(-54576,43994,-44130,-9191),List(35790,-98159,-43670,-71219)))
+  }
+
+  test("test6") {
+    assertEquals(Main.sortMatrix(List(59508, -30375, 53549),List(76794, -45364, 68655),List(59076, -95778, -72798)), List(List(59508,-30375,53549),List(76794,-45364,68655),List(59076,-95778,-72798)))
+  }
+
+  test("test7") {
+    assertEquals(Main.sortMatrix(List(70237, -28097, -75510, -93714, -13815, -81959, -59992, -43975, -70863),List(40288, 50377, -15278, -54865, -78871, 38194, -64139, -23739, 83299),List(75198, 26853, 45303, 17073, -52554, -69846, 41075, -10375, 61633),List(71858, 25443, -12504, 17141, 46172, -23439, 16688, 46570, 24044),List(59184, 60566, 13801, -28186, -2540, 59190, -3452, 81433, 67105),List(90462, 37330, 57191, -30681, -44432, -22472, 59534, 27280, 83274),List(99727, 15152, -37289, 36698, -39528, -47895, -50758, 75176, 62571),List(83565, -16059, -17953, -40686, 35575, -41645, -74717, -80703, 78122),List(12632, 65938, -48947, -75351, -84100, -18388, -96082, -97690, -92412)), List(List(70237,-28097,-75510,-93714,-13815,-81959,-59992,-43975,-70863),List(40288,50377,-15278,-54865,-78871,38194,-64139,-23739,83299),List(75198,26853,45303,17073,-52554,-69846,41075,-10375,61633),List(71858,25443,-12504,17141,46172,-23439,16688,46570,24044),List(59184,60566,13801,-28186,-2540,59190,-3452,81433,67105),List(90462,37330,57191,-30681,-44432,-22472,59534,27280,83274),List(99727,15152,-37289,36698,-39528,-47895,-50758,75176,62571),List(83565,-16059,-17953,-40686,35575,-41645,-74717,-80703,78122),List(12632,65938,-48947,-75351,-84100,-18388,-96082,-97690,-92412)))
+  }
+
+  test("test8") {
+    assertEquals(Main.sortMatrix(List(93680, -89587, -96793, -88056, -67363, -57242, -67539, -78121, -55829, -57391),List(70507, 28181, -65217, -76332, -42429, -38150, -48555, -2009, -63212, 39636),List(69116, 50346, 23408, -40122, -75329, 29472, -21407, -29091, -468, 29793),List(64817, 39118, 38117, 4200, 31191, -62081, 42875, 4261, 43215, 1967),List(73153, 49917, 23947, 32443, -25788, 51430, -30848, 66550, 62937, 91163),List(48378, 66018, 37406, -4699, 21998, -41176, 78126, 19189, 79570, 81497),List(-23104, 19536, 53987, 29462, -10253, 16954, -47341, 80533, 52244, 81496),List(66168, -30888, -18525, 40048, 23718, -52041, -14933, -49448, 90366, 99859),List(55807, 60419, -45089, -30668, 8678, -10026, -56978, -16041, -78687, 91900),List(-31370, -47928, -12268, -84613, -76766, -42972, -74771, -88090, -58183, -79213)), List(List(93680,-89587,-96793,-88056,-67363,-57242,-67539,-78121,-55829,-57391),List(70507,28181,-65217,-76332,-42429,-38150,-48555,-2009,-63212,39636),List(69116,50346,23408,-40122,-75329,29472,-21407,-29091,-468,29793),List(64817,39118,38117,4200,31191,-62081,42875,4261,43215,1967),List(73153,49917,23947,32443,-25788,51430,-30848,66550,62937,91163),List(48378,66018,37406,-4699,21998,-41176,78126,19189,79570,81497),List(-23104,19536,53987,29462,-10253,16954,-47341,80533,52244,81496),List(66168,-30888,-18525,40048,23718,-52041,-14933,-49448,90366,99859),List(55807,60419,-45089,-30668,8678,-10026,-56978,-16041,-78687,91900),List(-31370,-47928,-12268,-84613,-76766,-42972,-74771,-88090,-58183,-79213)))
+  }
+
+}

sort_the_people/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 (sortPeople [ \"Mary \", \"John \", \"Emma \"] [180,165,170])," ["Mary","Emma","John"] (sortPeople ["Mary","John","Emma"] [180,165,170]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (sortPeople [ \"Alice \", \"Bob \", \"Bob \"] [155,185,150])," ["Bob","Alice","Bob"] (sortPeople ["Alice","Bob","Bob"] [155,185,150]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

sort_the_people/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("Mary","Emma","John")), sortPeople(new ArrayList<>(Arrays.asList("Mary","John","Emma")), new ArrayList<>(Arrays.asList(180,165,170))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList("Bob","Alice","Bob")), sortPeople(new ArrayList<>(Arrays.asList("Alice","Bob","Bob")), new ArrayList<>(Arrays.asList(155,185,150))));
+}
+
+}

sort_the_people/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2502,
+    "name": "sort_the_people",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/sort-the-people/",
+    "date": "1663459200000",
+    "task_description": "You are given an array of strings `names`, and an array `heights` that consists of **distinct** positive integers. Both arrays are of length `n`. For each index `i`, `names[i]` and `heights[i]` denote the name and height of the `ith` person. Return `names`_ sorted in **descending** order by the people's heights_. **Example 1:** ``` **Input:** names = [\"Mary\",\"John\",\"Emma\"], heights = [180,165,170] **Output:** [\"Mary\",\"Emma\",\"John\"] **Explanation:** Mary is the tallest, followed by Emma and John. ``` **Example 2:** ``` **Input:** names = [\"Alice\",\"Bob\",\"Bob\"], heights = [155,185,150] **Output:** [\"Bob\",\"Alice\",\"Bob\"] **Explanation:** The first Bob is the tallest, followed by Alice and the second Bob. ``` **Constraints:** `n == names.length == heights.length` `1 <= n <= 103` `1 <= names[i].length <= 20` `1 <= heights[i] <= 105` `names[i]` consists of lower and upper case English letters. All the values of `heights` are distinct.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "names = [\"Mary\",\"John\",\"Emma\"], heights = [180,165,170]",
+            "output": "[\"Mary\",\"Emma\",\"John\"] "
+        },
+        {
+            "label": "Example 2",
+            "input": "names = [\"Alice\",\"Bob\",\"Bob\"], heights = [155,185,150]",
+            "output": "[\"Bob\",\"Alice\",\"Bob\"] "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "sortPeople :: [String] -> [Int] -> [String]\nsortPeople names heights ",
+    "ocaml_template": "let sortPeople (names: string list) (heights: int list) : string list =  ",
+    "scala_template": "def sortPeople(names: List[String],heights: List[Int]): List[String] = { \n    \n}",
+    "java_template": "public static List<String> sortPeople(List<String> names, List<Integer> heights) {\n\n}",
+    "python_template": "class Solution(object):\n    def sortPeople(self, names, heights):\n        \"\"\"\n        :type names: List[str]\n        :type heights: List[int]\n        :rtype: List[str]\n        \"\"\"\n        "
+}

sort_the_people/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal ["Mary";"Emma";"John"] (sortPeople ["Mary";"John";"Emma"] [180;165;170])
+
+let test2 _ = assert_equal ["Bob";"Alice";"Bob"] (sortPeople ["Alice";"Bob";"Bob"] [155;185;150])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for sortPeople" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

sort_the_people/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.sortPeople(List("Mary","John","Emma"),List(180,165,170)), List("Mary","Emma","John"))
+  }
+
+  test("test2") {
+    assertEquals(Main.sortPeople(List("Alice","Bob","Bob"),List(155,185,150)), List("Bob","Alice","Bob"))
+  }
+
+}

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

sort_vowels_in_a_string/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (sortVowels \"lEetcOde \")," "lEOtcede" (sortVowels "lEetcOde"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (sortVowels \"lYmpH \")," "lYmpH" (sortVowels "lYmpH"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

sort_vowels_in_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("lEetcOde", sortVowels("lEetcOde"));
+}
+@Test
+public void test2() {
+    assertEquals("lYmpH", sortVowels("lYmpH"));
+}
+
+}

sort_vowels_in_a_string/ocaml_tests/main.ml

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

sort_vowels_in_a_string/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.sortVowels("lEetcOde"), "lEOtcede")
+  }
+
+  test("test2") {
+    assertEquals(Main.sortVowels("lYmpH"), "lYmpH")
+  }
+
+}

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

sorted_gcd_pair_queries/meta.json

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

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