ac370624dbb37c2b82d6fa17b2f5684f2586e27dfa3c1a8dd9a13ce4a4dcb0ba

.gitattributes

@@ -175,3 +175,8 @@ maximum_difference_score_in_a_grid/meta.json filter=lfs diff=lfs merge=lfs -text
 maximum_elegance_of_a_k_length_subsequence/meta.json filter=lfs diff=lfs merge=lfs -text
 maximum_frequency_after_subarray_operation/meta.json filter=lfs diff=lfs merge=lfs -text
 maximum_frequency_of_an_element_after_performing_operations_i/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_frequency_of_an_element_after_performing_operations_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_good_subarray_sum/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_matching_of_players_with_trainers/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_number_of_groups_entering_a_competition/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_number_of_groups_with_increasing_length/meta.json filter=lfs diff=lfs merge=lfs -text

maximum_frequency_of_an_element_after_performing_operations_ii/java_tests/Main.java

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

maximum_frequency_of_an_element_after_performing_operations_ii/meta.json

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

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

maximum_good_subarray_sum/meta.json

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

maximum_height_of_a_triangle/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 (maxHeightOfTriangle 2 4)," 3 (maxHeightOfTriangle 2 4))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maxHeightOfTriangle 2 1)," 2 (maxHeightOfTriangle 2 1))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maxHeightOfTriangle 10 1)," 2 (maxHeightOfTriangle 10 1))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (maxHeightOfTriangle 23 10)," 6 (maxHeightOfTriangle 23 10))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (maxHeightOfTriangle 7 96)," 5 (maxHeightOfTriangle 7 96))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (maxHeightOfTriangle 60 61)," 14 (maxHeightOfTriangle 60 61))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (maxHeightOfTriangle 68 81)," 16 (maxHeightOfTriangle 68 81))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (maxHeightOfTriangle 49 74)," 14 (maxHeightOfTriangle 49 74))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (maxHeightOfTriangle 71 29)," 10 (maxHeightOfTriangle 71 29))
+
+
+-- 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

maximum_height_of_a_triangle/java_tests/Main.java

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

maximum_height_of_a_triangle/meta.json

@@ -0,0 +1,107 @@
+{
+    "id": 3469,
+    "name": "maximum_height_of_a_triangle",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/maximum-height-of-a-triangle/",
+    "date": "2024-06-23 00:00:00",
+    "task_description": "You are given two integers `red` and `blue` representing the count of red and blue colored balls. You have to arrange these balls to form a triangle such that the 1st row will have 1 ball, the 2nd row will have 2 balls, the 3rd row will have 3 balls, and so on. All the balls in a particular row should be the **same** color, and adjacent rows should have **different** colors. Return the **maximum**_ height of the triangle_ that can be achieved. **Example 1:** **Input:** red = 2, blue = 4 **Output:** 3 **Explanation:** The only possible arrangement is shown above. **Example 2:** **Input:** red = 2, blue = 1 **Output:** 2 **Explanation:** The only possible arrangement is shown above. **Example 3:** **Input:** red = 1, blue = 1 **Output:** 1 **Example 4:** **Input:** red = 10, blue = 1 **Output:** 2 **Explanation:** The only possible arrangement is shown above. **Constraints:** `1 <= red, blue <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "red = 2, blue = 4",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "red = 2, blue = 1",
+            "output": "2 "
+        },
+        {
+            "label": "Example 3",
+            "input": "red = 1, blue = 1",
+            "output": ""
+        },
+        {
+            "label": "Example 4",
+            "input": "red = 10, blue = 1",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                23,
+                10
+            ],
+            "output": 6
+        },
+        {
+            "input": [
+                7,
+                96
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                60,
+                61
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                68,
+                81
+            ],
+            "output": 16
+        },
+        {
+            "input": [
+                49,
+                74
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                71,
+                29
+            ],
+            "output": 10
+        },
+        {
+            "input": [
+                25,
+                5
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                75,
+                64
+            ],
+            "output": 16
+        },
+        {
+            "input": [
+                50,
+                46
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                9,
+                16
+            ],
+            "output": 6
+        }
+    ],
+    "haskell_template": "maxHeightOfTriangle :: Int -> Int -> Int\nmaxHeightOfTriangle red blue ",
+    "ocaml_template": "let maxHeightOfTriangle (red: int) (blue: int) : int =  ",
+    "scala_template": "def maxHeightOfTriangle(red: Int,blue: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int maxHeightOfTriangle(int red, int blue) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def maxHeightOfTriangle(self, red, blue):\n        \"\"\"\n        :type red: int\n        :type blue: int\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_height_of_a_triangle/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (maxHeightOfTriangle 2 4)
+
+let test2 _ = assert_equal 2 (maxHeightOfTriangle 2 1)
+
+let test3 _ = assert_equal 2 (maxHeightOfTriangle 10 1)
+
+let test4 _ = assert_equal 6 (maxHeightOfTriangle 23 10)
+
+let test5 _ = assert_equal 5 (maxHeightOfTriangle 7 96)
+
+let test6 _ = assert_equal 14 (maxHeightOfTriangle 60 61)
+
+let test7 _ = assert_equal 16 (maxHeightOfTriangle 68 81)
+
+let test8 _ = assert_equal 14 (maxHeightOfTriangle 49 74)
+
+let test9 _ = assert_equal 10 (maxHeightOfTriangle 71 29)
+
+let test10 _ = assert_equal 4 (maxHeightOfTriangle 25 5)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maxHeightOfTriangle" >::: [
+        
+  "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

maximum_height_of_a_triangle/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maxHeightOfTriangle(2,4), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.maxHeightOfTriangle(2,1), 2)
+  }
+
+  test("test3") {
+    assertEquals(Main.maxHeightOfTriangle(10,1), 2)
+  }
+
+  test("test4") {
+    assertEquals(Main.maxHeightOfTriangle(23,10), 6)
+  }
+
+  test("test5") {
+    assertEquals(Main.maxHeightOfTriangle(7,96), 5)
+  }
+
+  test("test6") {
+    assertEquals(Main.maxHeightOfTriangle(60,61), 14)
+  }
+
+  test("test7") {
+    assertEquals(Main.maxHeightOfTriangle(68,81), 16)
+  }
+
+  test("test8") {
+    assertEquals(Main.maxHeightOfTriangle(49,74), 14)
+  }
+
+  test("test9") {
+    assertEquals(Main.maxHeightOfTriangle(71,29), 10)
+  }
+
+  test("test10") {
+    assertEquals(Main.maxHeightOfTriangle(25,5), 4)
+  }
+
+}

maximum_manhattan_distance_after_k_changes/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, maxDistance("NWSE", 1));
+}
+@Test
+public void test2() {
+    assertEquals(6, maxDistance("NSWWEW", 3));
+}
+
+}

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

maximum_matching_of_players_with_trainers/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, matchPlayersAndTrainers(new ArrayList<>(Arrays.asList(4,7,9)), new ArrayList<>(Arrays.asList(8,2,5,8))));
+}
+@Test
+public void test2() {
+    assertEquals(1, matchPlayersAndTrainers(new ArrayList<>(Arrays.asList(1,1,1)), new ArrayList<>(Arrays.asList(10))));
+}
+
+}

maximum_matching_of_players_with_trainers/meta.json

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

maximum_matching_of_players_with_trainers/ocaml_tests/main.ml

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

maximum_matching_of_players_with_trainers/scala_tests/MySuite.scala

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

maximum_number_of_distinct_elements_after_operations/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(6, maxDistinctElements(new ArrayList<>(Arrays.asList(1,2,2,3,3,4)), 2));
+}
+@Test
+public void test2() {
+    assertEquals(3, maxDistinctElements(new ArrayList<>(Arrays.asList(4,4,4,4)), 1));
+}
+
+}

maximum_number_of_fish_in_a_grid/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+findMaxFish :: [[Int]] -> Int
+findMaxFish grid = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (findMaxFish [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]])," 7 (findMaxFish [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findMaxFish [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]])," 1 (findMaxFish [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (findMaxFish [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]])," 85 (findMaxFish [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (findMaxFish [[0, 0, 0, 0], [0, 0, 0, 0]])," 37 (findMaxFish [[0, 0, 0, 0], [0, 0, 0, 0]]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (findMaxFish [[0, 0, 0, 0, 0, 0]])," 35 (findMaxFish [[0, 0, 0, 0, 0, 0]]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (findMaxFish [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])," 196 (findMaxFish [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (findMaxFish [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])," 68 (findMaxFish [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

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

maximum_number_of_fish_in_a_grid/meta.json

@@ -0,0 +1,178 @@
+{
+    "id": 2764,
+    "name": "maximum_number_of_fish_in_a_grid",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/maximum-number-of-fish-in-a-grid/",
+    "date": "2023-04-15 00:00:00",
+    "task_description": "You are given a **0-indexed** 2D matrix `grid` of size `m x n`, where `(r, c)` represents: A **land** cell if `grid[r][c] = 0`, or A **water** cell containing `grid[r][c]` fish, if `grid[r][c] > 0`. A fisher can start at any **water** cell `(r, c)` and can do the following operations any number of times: Catch all the fish at cell `(r, c)`, or Move to any adjacent **water** cell. Return _the **maximum** number of fish the fisher can catch if he chooses his starting cell optimally, or _`0` if no water cell exists. An **adjacent** cell of the cell `(r, c)`, is one of the cells `(r, c + 1)`, `(r, c - 1)`, `(r + 1, c)` or `(r - 1, c)` if it exists. **Example 1:** ``` **Input:** grid = [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]] **Output:** 7 **Explanation:** The fisher can start at cell `(1,3)` and collect 3 fish, then move to cell `(2,3)` and collect 4 fish. ``` **Example 2:** ``` **Input:** grid = [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]] **Output:** 1 **Explanation:** The fisher can start at cells (0,0) or (3,3) and collect a single fish. ``` **Constraints:** `m == grid.length` `n == grid[i].length` `1 <= m, n <= 10` `0 <= grid[i][j] <= 10`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "grid = [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]]",
+            "output": "7 "
+        },
+        {
+            "label": "Example 2",
+            "input": "grid = [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0
+                ]
+            ],
+            "output": 85
+        },
+        {
+            "input": [
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ]
+            ],
+            "output": 37
+        },
+        {
+            "input": [
+                [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0
+                ]
+            ],
+            "output": 35
+        },
+        {
+            "input": [
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0,
+                    0
+                ]
+            ],
+            "output": 196
+        },
+        {
+            "input": [
+                [
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    0,
+                    0
+                ]
+            ],
+            "output": 68
+        }
+    ],
+    "haskell_template": "findMaxFish :: [[Int]] -> Int\nfindMaxFish grid ",
+    "ocaml_template": "let findMaxFish (grid: int list list) : int =  ",
+    "scala_template": "def findMaxFish(grid: List[List[Int]]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int findMaxFish(int[][] grid) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findMaxFish(self, grid):\n        \"\"\"\n        :type grid: List[List[int]]\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_number_of_fish_in_a_grid/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let findMaxFish (grid: int list list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 7 (findMaxFish [[0;2;1;0];[4;0;0;3];[1;0;0;4];[0;3;2;0]])
+
+let test2 _ = assert_equal 1 (findMaxFish [[1;0;0;0];[0;0;0;0];[0;0;0;0];[0;0;0;1]])
+
+let test3 _ = assert_equal 1 (findMaxFish [[0; 0]; [0; 0]; [0; 0]; [0; 0]; [0; 0]; [0; 0]; [0; 0]; [0; 0]])
+
+let test4 _ = assert_equal 1 (findMaxFish [[0; 0; 0; 0]; [0; 0; 0; 0]])
+
+let test5 _ = assert_equal 1 (findMaxFish [[0; 0; 0; 0; 0; 0]])
+
+let test6 _ = assert_equal 1 (findMaxFish [[0; 0; 0; 0]; [0; 0; 0; 0]; [0; 0; 0; 0]; [0; 0; 0; 0]; [0; 0; 0; 0]; [0; 0; 0; 0]; [0; 0; 0; 0]; [0; 0; 0; 0]; [0; 0; 0; 0]])
+
+let test7 _ = assert_equal 1 (findMaxFish [[0; 0; 0]; [0; 0; 0]; [0; 0; 0]; [0; 0; 0]])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for findMaxFish" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

maximum_number_of_fish_in_a_grid/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findMaxFish(List(List(0,2,1,0),List(4,0,0,3),List(1,0,0,4),List(0,3,2,0))), 7)
+  }
+
+  test("test2") {
+    assertEquals(Main.findMaxFish(List(List(1,0,0,0),List(0,0,0,0),List(0,0,0,0),List(0,0,0,1))), 1)
+  }
+
+  test("test3") {
+    assertEquals(Main.findMaxFish(List(0, 0),List(0, 0),List(0, 0),List(0, 0),List(0, 0),List(0, 0),List(0, 0),List(0, 0)), 85)
+  }
+
+  test("test4") {
+    assertEquals(Main.findMaxFish(List(0, 0, 0, 0),List(0, 0, 0, 0)), 37)
+  }
+
+  test("test5") {
+    assertEquals(Main.findMaxFish(List(0, 0, 0, 0, 0, 0)), 35)
+  }
+
+  test("test6") {
+    assertEquals(Main.findMaxFish(List(0, 0, 0, 0),List(0, 0, 0, 0),List(0, 0, 0, 0),List(0, 0, 0, 0),List(0, 0, 0, 0),List(0, 0, 0, 0),List(0, 0, 0, 0),List(0, 0, 0, 0),List(0, 0, 0, 0)), 196)
+  }
+
+  test("test7") {
+    assertEquals(Main.findMaxFish(List(0, 0, 0),List(0, 0, 0),List(0, 0, 0),List(0, 0, 0)), 68)
+  }
+
+}

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

maximum_number_of_groups_entering_a_competition/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, maximumGroups(new ArrayList<>(Arrays.asList(10,6,12,7,3,5))));
+}
+@Test
+public void test2() {
+    assertEquals(1, maximumGroups(new ArrayList<>(Arrays.asList(8,8))));
+}
+
+}

maximum_number_of_groups_entering_a_competition/meta.json

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

maximum_number_of_groups_entering_a_competition/ocaml_tests/main.ml

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

maximum_number_of_groups_entering_a_competition/scala_tests/MySuite.scala

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

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

maximum_number_of_groups_with_increasing_length/java_tests/Main.java

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

maximum_number_of_groups_with_increasing_length/meta.json

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

maximum_number_of_groups_with_increasing_length/ocaml_tests/main.ml

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