803548b7eea7d7363140b6f8aaf57360f973ef32663c952b21e1c1c24baa9bf5

.gitattributes

@@ -191,3 +191,10 @@ maximum_score_of_a_node_sequence/meta.json filter=lfs diff=lfs merge=lfs -text
 maximum_star_sum_of_a_graph/meta.json filter=lfs diff=lfs merge=lfs -text
 maximum_subarray_sum_with_length_divisible_by_k/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
 maximum_subarray_sum_with_length_divisible_by_k/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_sum_of_distinct_subarrays_with_length_k/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_sum_of_subsequence_with_non_adjacent_elements/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_sum_queries/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+maximum_sum_queries/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_sum_queries/ocaml_tests/main.ml filter=lfs diff=lfs merge=lfs -text
+maximum_sum_queries/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+maximum_tastiness_of_candy_basket/meta.json filter=lfs diff=lfs merge=lfs -text

maximum_subsequence_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(12, maxScore(new ArrayList<>(Arrays.asList(1,3,3,2)), new ArrayList<>(Arrays.asList(2,1,3,4)), 3));
+}
+@Test
+public void test2() {
+    assertEquals(30, maxScore(new ArrayList<>(Arrays.asList(4,2,3,1,1)), new ArrayList<>(Arrays.asList(7,5,10,9,6)), 1));
+}
+
+}

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

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

maximum_sum_of_almost_unique_subarray/ocaml_tests/main.ml

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

maximum_sum_of_almost_unique_subarray/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maxSum(List(2,6,7,3,1,7),3,4), 18)
+  }
+
+  test("test2") {
+    assertEquals(Main.maxSum(List(5,9,9,2,4,5,4),1,3), 23)
+  }
+
+  test("test3") {
+    assertEquals(Main.maxSum(List(1,2,1,2,1,2,1),3,3), 0)
+  }
+
+}

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

maximum_sum_of_an_hourglass/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(30, maxSum(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(6,2,1,3)),new ArrayList<>(Arrays.asList(4,2,1,5)),new ArrayList<>(Arrays.asList(9,2,8,7)),new ArrayList<>(Arrays.asList(4,1,2,9))))));
+}
+@Test
+public void test2() {
+    assertEquals(35, maxSum(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,2,3)),new ArrayList<>(Arrays.asList(4,5,6)),new ArrayList<>(Arrays.asList(7,8,9))))));
+}
+
+}

maximum_sum_of_an_hourglass/ocaml_tests/main.ml

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

maximum_sum_of_an_hourglass/scala_tests/MySuite.scala

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

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

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

maximum_sum_of_distinct_subarrays_with_length_k/meta.json

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

maximum_sum_of_distinct_subarrays_with_length_k/ocaml_tests/main.ml

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

maximum_sum_of_distinct_subarrays_with_length_k/scala_tests/MySuite.scala

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

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

maximum_sum_of_subsequence_with_non_adjacent_elements/meta.json

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

maximum_sum_queries/haskell_tests/Main.hs

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

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

maximum_sum_queries/meta.json

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

maximum_sum_queries/ocaml_tests/main.ml

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

maximum_sum_queries/scala_tests/MySuite.scala

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

maximum_sum_with_at_most_k_elements/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 (maxSum [[1,2],[3,4]] [1,2] 2)," 7 (maxSum [[1,2],[3,4]] [1,2] 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maxSum [[5,3,7],[8,2,6]] [2,2] 3)," 21 (maxSum [[5,3,7],[8,2,6]] [2,2] 3))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maxSum [[85260, 47422, 53625, 36747, 35594, 28797, 17386, 17212], [88531, 85530, 76965, 73095, 91830, 57035, 40917, 6379], [76486, 96359, 67702, 37662, 34499, 67026, 21931, 60146], [82976, 94923, 40907, 40371, 26172, 18157, 11966, 8383], [99722, 97724, 96166, 95370, 91702, 63781, 38317, 18411]] [8, 8, 3, 7, 6] 31)," 1936430 (maxSum [[85260, 47422, 53625, 36747, 35594, 28797, 17386, 17212], [88531, 85530, 76965, 73095, 91830, 57035, 40917, 6379], [76486, 96359, 67702, 37662, 34499, 67026, 21931, 60146], [82976, 94923, 40907, 40371, 26172, 18157, 11966, 8383], [99722, 97724, 96166, 95370, 91702, 63781, 38317, 18411]] [8, 8, 3, 7, 6] 31))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (maxSum [[99201, 75381, 25786, 47568, 39575, 53131, 20846, 30443]] [8] 0)," 0 (maxSum [[99201, 75381, 25786, 47568, 39575, 53131, 20846, 30443]] [8] 0))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (maxSum [[99113, 51916, 65503, 68687, 99547, 44294, 30149, 15959, 12781, 9287], [99043, 63459, 87093, 73661, 61210, 37723, 54030, 25083, 23938, 2843], [91499, 87846, 81731, 22610, 7877, 60272, 27361, 34701, 72751, 74092]] [9, 10, 3] 13)," 1032422 (maxSum [[99113, 51916, 65503, 68687, 99547, 44294, 30149, 15959, 12781, 9287], [99043, 63459, 87093, 73661, 61210, 37723, 54030, 25083, 23938, 2843], [91499, 87846, 81731, 22610, 7877, 60272, 27361, 34701, 72751, 74092]] [9, 10, 3] 13))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (maxSum [[77396, 71185, 66579, 53915, 45338, 34468, 33748, 23063, 14847], [88748, 57775, 57304, 55690, 5133, 26276, 33951, 9134, 49841], [86127, 99185, 91542, 89987, 81543, 67434, 38706, 35201, 16325], [85292, 84558, 84422, 57679, 81955, 80105, 15526, 22631, 40387], [97944, 80230, 69185, 66814, 66562, 40888, 26192, 5613, 3978], [97593, 36018, 34869, 34595, 23256, 19245, 12121, 5355, 13820], [83024, 55292, 54488, 47889, 40427, 26477, 13105, 10965, 10807], [38292, 94372, 72810, 53385, 38900, 36304, 21241, 17594, 21171], [98046, 55130, 95850, 63201, 65030, 55271, 42742, 39030, 13609]] [6, 4, 8, 2, 5, 5, 4, 6, 7] 20)," 1712051 (maxSum [[77396, 71185, 66579, 53915, 45338, 34468, 33748, 23063, 14847], [88748, 57775, 57304, 55690, 5133, 26276, 33951, 9134, 49841], [86127, 99185, 91542, 89987, 81543, 67434, 38706, 35201, 16325], [85292, 84558, 84422, 57679, 81955, 80105, 15526, 22631, 40387], [97944, 80230, 69185, 66814, 66562, 40888, 26192, 5613, 3978], [97593, 36018, 34869, 34595, 23256, 19245, 12121, 5355, 13820], [83024, 55292, 54488, 47889, 40427, 26477, 13105, 10965, 10807], [38292, 94372, 72810, 53385, 38900, 36304, 21241, 17594, 21171], [98046, 55130, 95850, 63201, 65030, 55271, 42742, 39030, 13609]] [6, 4, 8, 2, 5, 5, 4, 6, 7] 20))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (maxSum [[64638], [94336], [25444], [54487], [66368], [95785]] [1, 0, 0, 0, 0, 1] 1)," 95785 (maxSum [[64638], [94336], [25444], [54487], [66368], [95785]] [1, 0, 0, 0, 0, 1] 1))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (maxSum [[92742, 80876, 68577, 45679, 7633, 15336], [86141, 70975, 48255, 37017, 34398, 12550], [85980, 60142, 41618, 31614, 28519, 12337], [71522, 88380, 52692, 44141, 42349, 35045], [96109, 84777, 56237, 48867, 33293, 20946]] [2, 3, 1, 3, 2] 8)," 686527 (maxSum [[92742, 80876, 68577, 45679, 7633, 15336], [86141, 70975, 48255, 37017, 34398, 12550], [85980, 60142, 41618, 31614, 28519, 12337], [71522, 88380, 52692, 44141, 42349, 35045], [96109, 84777, 56237, 48867, 33293, 20946]] [2, 3, 1, 3, 2] 8))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (maxSum [[74678, 20231, 19180], [82050, 20624, 7449], [84397, 29107, 2718], [90313, 39443, 25013], [67980, 17651, 6582]] [1, 1, 2, 2, 1] 1)," 90313 (maxSum [[74678, 20231, 19180], [82050, 20624, 7449], [84397, 29107, 2718], [90313, 39443, 25013], [67980, 17651, 6582]] [1, 1, 2, 2, 1] 1))
+
+
+-- 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]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

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

maximum_sum_with_at_most_k_elements/meta.json

@@ -0,0 +1,409 @@
+{
+    "id": 3764,
+    "name": "maximum_sum_with_at_most_k_elements",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/maximum-sum-with-at-most-k-elements/",
+    "date": "2025-02-16 00:00:00",
+    "task_description": "You are given a 2D integer matrix `grid` of size `n x m`, an integer array `limits` of length `n`, and an integer `k`. The task is to find the **maximum sum** of **at most** `k` elements from the matrix `grid` such that: The number of elements taken from the `ith` row of `grid` does not exceed `limits[i]`. Return the **maximum sum**. **Example 1:** **Input:** grid = [[1,2],[3,4]], limits = [1,2], k = 2 **Output:** 7 **Explanation:** From the second row, we can take at most 2 elements. The elements taken are 4 and 3. The maximum possible sum of at most 2 selected elements is `4 + 3 = 7`. **Example 2:** **Input:** grid = [[5,3,7],[8,2,6]], limits = [2,2], k = 3 **Output:** 21 **Explanation:** From the first row, we can take at most 2 elements. The element taken is 7. From the second row, we can take at most 2 elements. The elements taken are 8 and 6. The maximum possible sum of at most 3 selected elements is `7 + 8 + 6 = 21`. **Constraints:** `n == grid.length == limits.length` `m == grid[i].length` `1 <= n, m <= 500` `0 <= grid[i][j] <= 105` `0 <= limits[i] <= m` `0 <= k <= min(n * m, sum(limits))`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "grid = [[1,2],[3,4]], limits = [1,2], k = 2",
+            "output": "7 "
+        },
+        {
+            "label": "Example 2",
+            "input": "grid = [[5,3,7],[8,2,6]], limits = [2,2], k = 3",
+            "output": "21 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    [
+                        85260,
+                        47422,
+                        53625,
+                        36747,
+                        35594,
+                        28797,
+                        17386,
+                        17212
+                    ],
+                    [
+                        88531,
+                        85530,
+                        76965,
+                        73095,
+                        91830,
+                        57035,
+                        40917,
+                        6379
+                    ],
+                    [
+                        76486,
+                        96359,
+                        67702,
+                        37662,
+                        34499,
+                        67026,
+                        21931,
+                        60146
+                    ],
+                    [
+                        82976,
+                        94923,
+                        40907,
+                        40371,
+                        26172,
+                        18157,
+                        11966,
+                        8383
+                    ],
+                    [
+                        99722,
+                        97724,
+                        96166,
+                        95370,
+                        91702,
+                        63781,
+                        38317,
+                        18411
+                    ]
+                ],
+                [
+                    8,
+                    8,
+                    3,
+                    7,
+                    6
+                ],
+                31
+            ],
+            "output": 1936430
+        },
+        {
+            "input": [
+                [
+                    [
+                        99201,
+                        75381,
+                        25786,
+                        47568,
+                        39575,
+                        53131,
+                        20846,
+                        30443
+                    ]
+                ],
+                [
+                    8
+                ],
+                0
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    [
+                        99113,
+                        51916,
+                        65503,
+                        68687,
+                        99547,
+                        44294,
+                        30149,
+                        15959,
+                        12781,
+                        9287
+                    ],
+                    [
+                        99043,
+                        63459,
+                        87093,
+                        73661,
+                        61210,
+                        37723,
+                        54030,
+                        25083,
+                        23938,
+                        2843
+                    ],
+                    [
+                        91499,
+                        87846,
+                        81731,
+                        22610,
+                        7877,
+                        60272,
+                        27361,
+                        34701,
+                        72751,
+                        74092
+                    ]
+                ],
+                [
+                    9,
+                    10,
+                    3
+                ],
+                13
+            ],
+            "output": 1032422
+        },
+        {
+            "input": [
+                [
+                    [
+                        77396,
+                        71185,
+                        66579,
+                        53915,
+                        45338,
+                        34468,
+                        33748,
+                        23063,
+                        14847
+                    ],
+                    [
+                        88748,
+                        57775,
+                        57304,
+                        55690,
+                        5133,
+                        26276,
+                        33951,
+                        9134,
+                        49841
+                    ],
+                    [
+                        86127,
+                        99185,
+                        91542,
+                        89987,
+                        81543,
+                        67434,
+                        38706,
+                        35201,
+                        16325
+                    ],
+                    [
+                        85292,
+                        84558,
+                        84422,
+                        57679,
+                        81955,
+                        80105,
+                        15526,
+                        22631,
+                        40387
+                    ],
+                    [
+                        97944,
+                        80230,
+                        69185,
+                        66814,
+                        66562,
+                        40888,
+                        26192,
+                        5613,
+                        3978
+                    ],
+                    [
+                        97593,
+                        36018,
+                        34869,
+                        34595,
+                        23256,
+                        19245,
+                        12121,
+                        5355,
+                        13820
+                    ],
+                    [
+                        83024,
+                        55292,
+                        54488,
+                        47889,
+                        40427,
+                        26477,
+                        13105,
+                        10965,
+                        10807
+                    ],
+                    [
+                        38292,
+                        94372,
+                        72810,
+                        53385,
+                        38900,
+                        36304,
+                        21241,
+                        17594,
+                        21171
+                    ],
+                    [
+                        98046,
+                        55130,
+                        95850,
+                        63201,
+                        65030,
+                        55271,
+                        42742,
+                        39030,
+                        13609
+                    ]
+                ],
+                [
+                    6,
+                    4,
+                    8,
+                    2,
+                    5,
+                    5,
+                    4,
+                    6,
+                    7
+                ],
+                20
+            ],
+            "output": 1712051
+        },
+        {
+            "input": [
+                [
+                    [
+                        64638
+                    ],
+                    [
+                        94336
+                    ],
+                    [
+                        25444
+                    ],
+                    [
+                        54487
+                    ],
+                    [
+                        66368
+                    ],
+                    [
+                        95785
+                    ]
+                ],
+                [
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1
+                ],
+                1
+            ],
+            "output": 95785
+        },
+        {
+            "input": [
+                [
+                    [
+                        92742,
+                        80876,
+                        68577,
+                        45679,
+                        7633,
+                        15336
+                    ],
+                    [
+                        86141,
+                        70975,
+                        48255,
+                        37017,
+                        34398,
+                        12550
+                    ],
+                    [
+                        85980,
+                        60142,
+                        41618,
+                        31614,
+                        28519,
+                        12337
+                    ],
+                    [
+                        71522,
+                        88380,
+                        52692,
+                        44141,
+                        42349,
+                        35045
+                    ],
+                    [
+                        96109,
+                        84777,
+                        56237,
+                        48867,
+                        33293,
+                        20946
+                    ]
+                ],
+                [
+                    2,
+                    3,
+                    1,
+                    3,
+                    2
+                ],
+                8
+            ],
+            "output": 686527
+        },
+        {
+            "input": [
+                [
+                    [
+                        74678,
+                        20231,
+                        19180
+                    ],
+                    [
+                        82050,
+                        20624,
+                        7449
+                    ],
+                    [
+                        84397,
+                        29107,
+                        2718
+                    ],
+                    [
+                        90313,
+                        39443,
+                        25013
+                    ],
+                    [
+                        67980,
+                        17651,
+                        6582
+                    ]
+                ],
+                [
+                    1,
+                    1,
+                    2,
+                    2,
+                    1
+                ],
+                1
+            ],
+            "output": 90313
+        }
+    ],
+    "haskell_template": "maxSum :: [[Int]] -> [Int] -> Int -> Int\nmaxSum grid limits k ",
+    "ocaml_template": "let maxSum (grid: int list list) (limits: int list) (k: int) : int =  ",
+    "scala_template": "def maxSum(grid: List[List[Int]],limits: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long maxSum(int[][] grid, int[] limits, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def maxSum(self, grid, limits, k):\n        \"\"\"\n        :type grid: List[List[int]]\n        :type limits: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_sum_with_at_most_k_elements/ocaml_tests/main.ml

@@ -0,0 +1,47 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 7 (maxSum [[1;2];[3;4]] [1;2] 2)
+
+let test2 _ = assert_equal 21 (maxSum [[5;3;7];[8;2;6]] [2;2] 3)
+
+let test3 _ = assert_equal 1936430 (maxSum [[85260; 47422; 53625; 36747; 35594; 28797; 17386; 17212]; [88531; 85530; 76965; 73095; 91830; 57035; 40917; 6379]; [76486; 96359; 67702; 37662; 34499; 67026; 21931; 60146]; [82976; 94923; 40907; 40371; 26172; 18157; 11966; 8383]; [99722; 97724; 96166; 95370; 91702; 63781; 38317; 18411]] [8; 8; 3; 7; 6] 31)
+
+let test4 _ = assert_equal 0 (maxSum [[99201; 75381; 25786; 47568; 39575; 53131; 20846; 30443]] [8] 0)
+
+let test5 _ = assert_equal 1032422 (maxSum [[99113; 51916; 65503; 68687; 99547; 44294; 30149; 15959; 12781; 9287]; [99043; 63459; 87093; 73661; 61210; 37723; 54030; 25083; 23938; 2843]; [91499; 87846; 81731; 22610; 7877; 60272; 27361; 34701; 72751; 74092]] [9; 10; 3] 13)
+
+let test6 _ = assert_equal 1712051 (maxSum [[77396; 71185; 66579; 53915; 45338; 34468; 33748; 23063; 14847]; [88748; 57775; 57304; 55690; 5133; 26276; 33951; 9134; 49841]; [86127; 99185; 91542; 89987; 81543; 67434; 38706; 35201; 16325]; [85292; 84558; 84422; 57679; 81955; 80105; 15526; 22631; 40387]; [97944; 80230; 69185; 66814; 66562; 40888; 26192; 5613; 3978]; [97593; 36018; 34869; 34595; 23256; 19245; 12121; 5355; 13820]; [83024; 55292; 54488; 47889; 40427; 26477; 13105; 10965; 10807]; [38292; 94372; 72810; 53385; 38900; 36304; 21241; 17594; 21171]; [98046; 55130; 95850; 63201; 65030; 55271; 42742; 39030; 13609]] [6; 4; 8; 2; 5; 5; 4; 6; 7] 20)
+
+let test7 _ = assert_equal 95785 (maxSum [[64638]; [94336]; [25444]; [54487]; [66368]; [95785]] [1; 0; 0; 0; 0; 1] 1)
+
+let test8 _ = assert_equal 686527 (maxSum [[92742; 80876; 68577; 45679; 7633; 15336]; [86141; 70975; 48255; 37017; 34398; 12550]; [85980; 60142; 41618; 31614; 28519; 12337]; [71522; 88380; 52692; 44141; 42349; 35045]; [96109; 84777; 56237; 48867; 33293; 20946]] [2; 3; 1; 3; 2] 8)
+
+let test9 _ = assert_equal 90313 (maxSum [[74678; 20231; 19180]; [82050; 20624; 7449]; [84397; 29107; 2718]; [90313; 39443; 25013]; [67980; 17651; 6582]] [1; 1; 2; 2; 1] 1)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maxSum" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+  "test9" >:: test9;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

maximum_sum_with_at_most_k_elements/scala_tests/MySuite.scala

@@ -0,0 +1,40 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maxSum(List(List(1,2),List(3,4)),List(1,2),2), 7)
+  }
+
+  test("test2") {
+    assertEquals(Main.maxSum(List(List(5,3,7),List(8,2,6)),List(2,2),3), 21)
+  }
+
+  test("test3") {
+    assertEquals(Main.maxSum(List(List(85260, 47422, 53625, 36747, 35594, 28797, 17386, 17212), List(88531, 85530, 76965, 73095, 91830, 57035, 40917, 6379), List(76486, 96359, 67702, 37662, 34499, 67026, 21931, 60146), List(82976, 94923, 40907, 40371, 26172, 18157, 11966, 8383), List(99722, 97724, 96166, 95370, 91702, 63781, 38317, 18411)),List(8, 8, 3, 7, 6),31), 1936430)
+  }
+
+  test("test4") {
+    assertEquals(Main.maxSum(List(List(99201, 75381, 25786, 47568, 39575, 53131, 20846, 30443)),List(8),0), 0)
+  }
+
+  test("test5") {
+    assertEquals(Main.maxSum(List(List(99113, 51916, 65503, 68687, 99547, 44294, 30149, 15959, 12781, 9287), List(99043, 63459, 87093, 73661, 61210, 37723, 54030, 25083, 23938, 2843), List(91499, 87846, 81731, 22610, 7877, 60272, 27361, 34701, 72751, 74092)),List(9, 10, 3),13), 1032422)
+  }
+
+  test("test6") {
+    assertEquals(Main.maxSum(List(List(77396, 71185, 66579, 53915, 45338, 34468, 33748, 23063, 14847), List(88748, 57775, 57304, 55690, 5133, 26276, 33951, 9134, 49841), List(86127, 99185, 91542, 89987, 81543, 67434, 38706, 35201, 16325), List(85292, 84558, 84422, 57679, 81955, 80105, 15526, 22631, 40387), List(97944, 80230, 69185, 66814, 66562, 40888, 26192, 5613, 3978), List(97593, 36018, 34869, 34595, 23256, 19245, 12121, 5355, 13820), List(83024, 55292, 54488, 47889, 40427, 26477, 13105, 10965, 10807), List(38292, 94372, 72810, 53385, 38900, 36304, 21241, 17594, 21171), List(98046, 55130, 95850, 63201, 65030, 55271, 42742, 39030, 13609)),List(6, 4, 8, 2, 5, 5, 4, 6, 7),20), 1712051)
+  }
+
+  test("test7") {
+    assertEquals(Main.maxSum(List(List(64638), List(94336), List(25444), List(54487), List(66368), List(95785)),List(1, 0, 0, 0, 0, 1),1), 95785)
+  }
+
+  test("test8") {
+    assertEquals(Main.maxSum(List(List(92742, 80876, 68577, 45679, 7633, 15336), List(86141, 70975, 48255, 37017, 34398, 12550), List(85980, 60142, 41618, 31614, 28519, 12337), List(71522, 88380, 52692, 44141, 42349, 35045), List(96109, 84777, 56237, 48867, 33293, 20946)),List(2, 3, 1, 3, 2),8), 686527)
+  }
+
+  test("test9") {
+    assertEquals(Main.maxSum(List(List(74678, 20231, 19180), List(82050, 20624, 7449), List(84397, 29107, 2718), List(90313, 39443, 25013), List(67980, 17651, 6582)),List(1, 1, 2, 2, 1),1), 90313)
+  }
+
+}

maximum_sum_with_exactly_k_elements/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 (maximizeSum [1,2,3,4,5] 3)," 18 (maximizeSum [1,2,3,4,5] 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maximizeSum [5,5,5] 2)," 11 (maximizeSum [5,5,5] 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maximizeSum [49, 90, 3, 56, 32, 100, 38, 12, 5, 5, 90, 14, 20, 83, 97, 40, 69, 52, 50, 24, 82, 83, 2, 35, 20, 45, 36, 69, 22, 14, 35, 76, 50] 65)," 8580 (maximizeSum [49, 90, 3, 56, 32, 100, 38, 12, 5, 5, 90, 14, 20, 83, 97, 40, 69, 52, 50, 24, 82, 83, 2, 35, 20, 45, 36, 69, 22, 14, 35, 76, 50] 65))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (maximizeSum [44, 73, 34, 84, 91, 13, 23, 46, 6, 14, 30, 85, 75, 70, 79, 7, 60, 30, 57, 27, 59, 49] 22)," 2233 (maximizeSum [44, 73, 34, 84, 91, 13, 23, 46, 6, 14, 30, 85, 75, 70, 79, 7, 60, 30, 57, 27, 59, 49] 22))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (maximizeSum [81, 14, 40, 34, 54, 23, 63, 65, 84, 84, 4, 37, 88, 41, 8, 33, 54, 18, 49, 67, 85, 37, 78, 46, 38, 80, 13, 77, 93, 5, 3, 12, 89, 36, 44, 63, 41, 22, 95, 86, 11, 44, 74, 82, 48, 57, 90, 35, 44, 46, 71, 66, 6, 3, 1, 26, 38, 47, 70, 24, 3, 54, 67, 48, 89, 4, 57, 41, 69, 77, 24, 74, 26, 78, 67, 22, 84] 71)," 9230 (maximizeSum [81, 14, 40, 34, 54, 23, 63, 65, 84, 84, 4, 37, 88, 41, 8, 33, 54, 18, 49, 67, 85, 37, 78, 46, 38, 80, 13, 77, 93, 5, 3, 12, 89, 36, 44, 63, 41, 22, 95, 86, 11, 44, 74, 82, 48, 57, 90, 35, 44, 46, 71, 66, 6, 3, 1, 26, 38, 47, 70, 24, 3, 54, 67, 48, 89, 4, 57, 41, 69, 77, 24, 74, 26, 78, 67, 22, 84] 71))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (maximizeSum [12, 50, 78, 77, 47, 31, 50, 24, 58, 8, 53, 44, 27, 74, 1, 64, 44, 64, 87, 93, 1, 71, 56, 29, 35, 99, 95, 57, 86, 90, 78, 95, 29, 1, 26, 5, 51, 43, 84, 58, 29, 66, 74, 36, 6, 69, 67, 63, 2, 77, 47, 12, 22, 13, 13, 100, 66, 92, 32, 76, 66, 71, 40, 64, 63, 76, 7, 2, 100, 5, 53, 14, 21, 44, 37, 21, 97, 38, 31, 22] 58)," 7453 (maximizeSum [12, 50, 78, 77, 47, 31, 50, 24, 58, 8, 53, 44, 27, 74, 1, 64, 44, 64, 87, 93, 1, 71, 56, 29, 35, 99, 95, 57, 86, 90, 78, 95, 29, 1, 26, 5, 51, 43, 84, 58, 29, 66, 74, 36, 6, 69, 67, 63, 2, 77, 47, 12, 22, 13, 13, 100, 66, 92, 32, 76, 66, 71, 40, 64, 63, 76, 7, 2, 100, 5, 53, 14, 21, 44, 37, 21, 97, 38, 31, 22] 58))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (maximizeSum [3, 69, 95, 56, 57, 13, 12, 63, 17, 22, 96, 67, 5, 32, 79, 5, 43, 39, 26, 53, 32, 82, 95, 1, 68, 94, 21, 93, 54, 75, 36, 19, 43, 93, 5, 16, 28, 84, 17, 44, 11, 96, 73, 37, 54, 92, 79, 56, 58, 33, 82, 67, 44, 82, 41, 83, 55, 42, 16, 46] 75)," 9975 (maximizeSum [3, 69, 95, 56, 57, 13, 12, 63, 17, 22, 96, 67, 5, 32, 79, 5, 43, 39, 26, 53, 32, 82, 95, 1, 68, 94, 21, 93, 54, 75, 36, 19, 43, 93, 5, 16, 28, 84, 17, 44, 11, 96, 73, 37, 54, 92, 79, 56, 58, 33, 82, 67, 44, 82, 41, 83, 55, 42, 16, 46] 75))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (maximizeSum [47, 16, 81, 75, 82, 87, 11, 52, 71, 8, 61, 31, 52, 38, 55, 74, 89, 15, 9, 49, 48, 87, 36, 84, 45, 77, 92, 24, 37, 64, 40, 29, 18, 87, 95, 80, 41, 84, 12, 76, 75, 90, 13, 65, 84] 15)," 1530 (maximizeSum [47, 16, 81, 75, 82, 87, 11, 52, 71, 8, 61, 31, 52, 38, 55, 74, 89, 15, 9, 49, 48, 87, 36, 84, 45, 77, 92, 24, 37, 64, 40, 29, 18, 87, 95, 80, 41, 84, 12, 76, 75, 90, 13, 65, 84] 15))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (maximizeSum [98, 56, 51, 95, 91, 66, 51, 40, 34, 51, 7, 48, 37, 61] 5)," 500 (maximizeSum [98, 56, 51, 95, 91, 66, 51, 40, 34, 51, 7, 48, 37, 61] 5))
+
+
+-- 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_sum_with_exactly_k_elements/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(18, maximizeSum(new ArrayList<>(Arrays.asList(1,2,3,4,5)), 3));
+}
+@Test
+public void test2() {
+    assertEquals(11, maximizeSum(new ArrayList<>(Arrays.asList(5,5,5)), 2));
+}
+
+}

maximum_sum_with_exactly_k_elements/meta.json

@@ -0,0 +1,718 @@
+{
+    "id": 2767,
+    "name": "maximum_sum_with_exactly_k_elements",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/maximum-sum-with-exactly-k-elements/",
+    "date": "2023-04-15 00:00:00",
+    "task_description": "You are given a **0-indexed** integer array `nums` and an integer `k`. Your task is to perform the following operation **exactly** `k` times in order to maximize your score: Select an element `m` from `nums`. Remove the selected element `m` from the array. Add a new element with a value of `m + 1` to the array. Increase your score by `m`. Return _the maximum score you can achieve after performing the operation exactly_ `k` _times._ **Example 1:** ``` **Input:** nums = [1,2,3,4,5], k = 3 **Output:** 18 **Explanation:** We need to choose exactly 3 elements from nums to maximize the sum. For the first iteration, we choose 5. Then sum is 5 and nums = [1,2,3,4,6] For the second iteration, we choose 6. Then sum is 5 + 6 and nums = [1,2,3,4,7] For the third iteration, we choose 7. Then sum is 5 + 6 + 7 = 18 and nums = [1,2,3,4,8] So, we will return 18. It can be proven, that 18 is the maximum answer that we can achieve. ``` **Example 2:** ``` **Input:** nums = [5,5,5], k = 2 **Output:** 11 **Explanation:** We need to choose exactly 2 elements from nums to maximize the sum. For the first iteration, we choose 5. Then sum is 5 and nums = [5,5,6] For the second iteration, we choose 6. Then sum is 5 + 6 = 11 and nums = [5,5,7] So, we will return 11. It can be proven, that 11 is the maximum answer that we can achieve. ``` **Constraints:** `1 <= nums.length <= 100` `1 <= nums[i] <= 100` `1 <= k <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3,4,5], k = 3",
+            "output": "18 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [5,5,5], k = 2",
+            "output": "11 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    49,
+                    90,
+                    3,
+                    56,
+                    32,
+                    100,
+                    38,
+                    12,
+                    5,
+                    5,
+                    90,
+                    14,
+                    20,
+                    83,
+                    97,
+                    40,
+                    69,
+                    52,
+                    50,
+                    24,
+                    82,
+                    83,
+                    2,
+                    35,
+                    20,
+                    45,
+                    36,
+                    69,
+                    22,
+                    14,
+                    35,
+                    76,
+                    50
+                ],
+                65
+            ],
+            "output": 8580
+        },
+        {
+            "input": [
+                [
+                    44,
+                    73,
+                    34,
+                    84,
+                    91,
+                    13,
+                    23,
+                    46,
+                    6,
+                    14,
+                    30,
+                    85,
+                    75,
+                    70,
+                    79,
+                    7,
+                    60,
+                    30,
+                    57,
+                    27,
+                    59,
+                    49
+                ],
+                22
+            ],
+            "output": 2233
+        },
+        {
+            "input": [
+                [
+                    81,
+                    14,
+                    40,
+                    34,
+                    54,
+                    23,
+                    63,
+                    65,
+                    84,
+                    84,
+                    4,
+                    37,
+                    88,
+                    41,
+                    8,
+                    33,
+                    54,
+                    18,
+                    49,
+                    67,
+                    85,
+                    37,
+                    78,
+                    46,
+                    38,
+                    80,
+                    13,
+                    77,
+                    93,
+                    5,
+                    3,
+                    12,
+                    89,
+                    36,
+                    44,
+                    63,
+                    41,
+                    22,
+                    95,
+                    86,
+                    11,
+                    44,
+                    74,
+                    82,
+                    48,
+                    57,
+                    90,
+                    35,
+                    44,
+                    46,
+                    71,
+                    66,
+                    6,
+                    3,
+                    1,
+                    26,
+                    38,
+                    47,
+                    70,
+                    24,
+                    3,
+                    54,
+                    67,
+                    48,
+                    89,
+                    4,
+                    57,
+                    41,
+                    69,
+                    77,
+                    24,
+                    74,
+                    26,
+                    78,
+                    67,
+                    22,
+                    84
+                ],
+                71
+            ],
+            "output": 9230
+        },
+        {
+            "input": [
+                [
+                    12,
+                    50,
+                    78,
+                    77,
+                    47,
+                    31,
+                    50,
+                    24,
+                    58,
+                    8,
+                    53,
+                    44,
+                    27,
+                    74,
+                    1,
+                    64,
+                    44,
+                    64,
+                    87,
+                    93,
+                    1,
+                    71,
+                    56,
+                    29,
+                    35,
+                    99,
+                    95,
+                    57,
+                    86,
+                    90,
+                    78,
+                    95,
+                    29,
+                    1,
+                    26,
+                    5,
+                    51,
+                    43,
+                    84,
+                    58,
+                    29,
+                    66,
+                    74,
+                    36,
+                    6,
+                    69,
+                    67,
+                    63,
+                    2,
+                    77,
+                    47,
+                    12,
+                    22,
+                    13,
+                    13,
+                    100,
+                    66,
+                    92,
+                    32,
+                    76,
+                    66,
+                    71,
+                    40,
+                    64,
+                    63,
+                    76,
+                    7,
+                    2,
+                    100,
+                    5,
+                    53,
+                    14,
+                    21,
+                    44,
+                    37,
+                    21,
+                    97,
+                    38,
+                    31,
+                    22
+                ],
+                58
+            ],
+            "output": 7453
+        },
+        {
+            "input": [
+                [
+                    3,
+                    69,
+                    95,
+                    56,
+                    57,
+                    13,
+                    12,
+                    63,
+                    17,
+                    22,
+                    96,
+                    67,
+                    5,
+                    32,
+                    79,
+                    5,
+                    43,
+                    39,
+                    26,
+                    53,
+                    32,
+                    82,
+                    95,
+                    1,
+                    68,
+                    94,
+                    21,
+                    93,
+                    54,
+                    75,
+                    36,
+                    19,
+                    43,
+                    93,
+                    5,
+                    16,
+                    28,
+                    84,
+                    17,
+                    44,
+                    11,
+                    96,
+                    73,
+                    37,
+                    54,
+                    92,
+                    79,
+                    56,
+                    58,
+                    33,
+                    82,
+                    67,
+                    44,
+                    82,
+                    41,
+                    83,
+                    55,
+                    42,
+                    16,
+                    46
+                ],
+                75
+            ],
+            "output": 9975
+        },
+        {
+            "input": [
+                [
+                    47,
+                    16,
+                    81,
+                    75,
+                    82,
+                    87,
+                    11,
+                    52,
+                    71,
+                    8,
+                    61,
+                    31,
+                    52,
+                    38,
+                    55,
+                    74,
+                    89,
+                    15,
+                    9,
+                    49,
+                    48,
+                    87,
+                    36,
+                    84,
+                    45,
+                    77,
+                    92,
+                    24,
+                    37,
+                    64,
+                    40,
+                    29,
+                    18,
+                    87,
+                    95,
+                    80,
+                    41,
+                    84,
+                    12,
+                    76,
+                    75,
+                    90,
+                    13,
+                    65,
+                    84
+                ],
+                15
+            ],
+            "output": 1530
+        },
+        {
+            "input": [
+                [
+                    98,
+                    56,
+                    51,
+                    95,
+                    91,
+                    66,
+                    51,
+                    40,
+                    34,
+                    51,
+                    7,
+                    48,
+                    37,
+                    61
+                ],
+                5
+            ],
+            "output": 500
+        },
+        {
+            "input": [
+                [
+                    70,
+                    63,
+                    30,
+                    79,
+                    46,
+                    21,
+                    18,
+                    4,
+                    3,
+                    90,
+                    10,
+                    4,
+                    66,
+                    49,
+                    80,
+                    59,
+                    44,
+                    75,
+                    22,
+                    80,
+                    14,
+                    26,
+                    52,
+                    13,
+                    1,
+                    45,
+                    94,
+                    34,
+                    18,
+                    64,
+                    64,
+                    99,
+                    46,
+                    77,
+                    4,
+                    16,
+                    98,
+                    26,
+                    21,
+                    28,
+                    94,
+                    97,
+                    96,
+                    64,
+                    55,
+                    17,
+                    43,
+                    50,
+                    88,
+                    36,
+                    92,
+                    81,
+                    9,
+                    46,
+                    64,
+                    98,
+                    52,
+                    52,
+                    90,
+                    71,
+                    83,
+                    14,
+                    55,
+                    29,
+                    58,
+                    79,
+                    24,
+                    98,
+                    9,
+                    3,
+                    21,
+                    61,
+                    46,
+                    83,
+                    52,
+                    79,
+                    65,
+                    44,
+                    94,
+                    81,
+                    17,
+                    52,
+                    72,
+                    50,
+                    35,
+                    20,
+                    36,
+                    95,
+                    84
+                ],
+                75
+            ],
+            "output": 10200
+        },
+        {
+            "input": [
+                [
+                    93,
+                    89,
+                    46,
+                    52,
+                    63,
+                    18,
+                    87,
+                    33,
+                    74,
+                    49,
+                    27,
+                    50,
+                    69,
+                    41,
+                    78,
+                    5,
+                    17,
+                    74,
+                    58,
+                    37,
+                    77,
+                    25,
+                    56,
+                    7,
+                    83,
+                    43,
+                    54,
+                    65,
+                    96,
+                    51,
+                    52,
+                    29,
+                    14,
+                    85,
+                    15,
+                    66,
+                    20,
+                    71,
+                    82,
+                    31,
+                    24,
+                    33,
+                    49,
+                    95,
+                    14,
+                    6,
+                    18,
+                    63,
+                    28,
+                    91,
+                    87,
+                    62,
+                    56,
+                    57,
+                    81,
+                    72,
+                    2,
+                    21,
+                    70,
+                    41,
+                    37,
+                    45,
+                    10,
+                    81,
+                    74,
+                    10,
+                    83,
+                    16,
+                    93,
+                    53,
+                    88,
+                    32,
+                    100,
+                    20,
+                    63,
+                    100,
+                    20,
+                    21,
+                    36,
+                    27,
+                    34,
+                    14,
+                    62,
+                    9,
+                    44,
+                    82,
+                    64,
+                    54,
+                    69,
+                    49,
+                    10,
+                    89,
+                    82,
+                    15,
+                    99,
+                    18,
+                    46,
+                    51,
+                    71
+                ],
+                99
+            ],
+            "output": 14751
+        },
+        {
+            "input": [
+                [
+                    9,
+                    97,
+                    21,
+                    77,
+                    53,
+                    18,
+                    74,
+                    32,
+                    9,
+                    82,
+                    52,
+                    49,
+                    18,
+                    9,
+                    28,
+                    7,
+                    62,
+                    42,
+                    94,
+                    29,
+                    6,
+                    81,
+                    4,
+                    82,
+                    55,
+                    33,
+                    100,
+                    34,
+                    30,
+                    50,
+                    13,
+                    80,
+                    48,
+                    68,
+                    86,
+                    6,
+                    61,
+                    7,
+                    92,
+                    75,
+                    63,
+                    17,
+                    8,
+                    77,
+                    97,
+                    36,
+                    88,
+                    83,
+                    99,
+                    88,
+                    90,
+                    27,
+                    16,
+                    19,
+                    92,
+                    35,
+                    31,
+                    62,
+                    75,
+                    32,
+                    96,
+                    6,
+                    68,
+                    47,
+                    82,
+                    90,
+                    88,
+                    53,
+                    66,
+                    6,
+                    50,
+                    9,
+                    82,
+                    1,
+                    25,
+                    67,
+                    31,
+                    31,
+                    11,
+                    82,
+                    43,
+                    90,
+                    15,
+                    19,
+                    97,
+                    43,
+                    46,
+                    93,
+                    85,
+                    62,
+                    97,
+                    21
+                ],
+                8
+            ],
+            "output": 828
+        }
+    ],
+    "haskell_template": "maximizeSum :: [Int] -> Int -> Int\nmaximizeSum nums k ",
+    "ocaml_template": "let maximizeSum (nums: int list) (k: int) : int =  ",
+    "scala_template": "def maximizeSum(nums: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int maximizeSum(int[] nums, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def maximizeSum(self, nums, k):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_sum_with_exactly_k_elements/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 18 (maximizeSum [1;2;3;4;5] 3)
+
+let test2 _ = assert_equal 11 (maximizeSum [5;5;5] 2)
+
+let test3 _ = assert_equal 8580 (maximizeSum [49; 90; 3; 56; 32; 100; 38; 12; 5; 5; 90; 14; 20; 83; 97; 40; 69; 52; 50; 24; 82; 83; 2; 35; 20; 45; 36; 69; 22; 14; 35; 76; 50] 65)
+
+let test4 _ = assert_equal 2233 (maximizeSum [44; 73; 34; 84; 91; 13; 23; 46; 6; 14; 30; 85; 75; 70; 79; 7; 60; 30; 57; 27; 59; 49] 22)
+
+let test5 _ = assert_equal 9230 (maximizeSum [81; 14; 40; 34; 54; 23; 63; 65; 84; 84; 4; 37; 88; 41; 8; 33; 54; 18; 49; 67; 85; 37; 78; 46; 38; 80; 13; 77; 93; 5; 3; 12; 89; 36; 44; 63; 41; 22; 95; 86; 11; 44; 74; 82; 48; 57; 90; 35; 44; 46; 71; 66; 6; 3; 1; 26; 38; 47; 70; 24; 3; 54; 67; 48; 89; 4; 57; 41; 69; 77; 24; 74; 26; 78; 67; 22; 84] 71)
+
+let test6 _ = assert_equal 7453 (maximizeSum [12; 50; 78; 77; 47; 31; 50; 24; 58; 8; 53; 44; 27; 74; 1; 64; 44; 64; 87; 93; 1; 71; 56; 29; 35; 99; 95; 57; 86; 90; 78; 95; 29; 1; 26; 5; 51; 43; 84; 58; 29; 66; 74; 36; 6; 69; 67; 63; 2; 77; 47; 12; 22; 13; 13; 100; 66; 92; 32; 76; 66; 71; 40; 64; 63; 76; 7; 2; 100; 5; 53; 14; 21; 44; 37; 21; 97; 38; 31; 22] 58)
+
+let test7 _ = assert_equal 9975 (maximizeSum [3; 69; 95; 56; 57; 13; 12; 63; 17; 22; 96; 67; 5; 32; 79; 5; 43; 39; 26; 53; 32; 82; 95; 1; 68; 94; 21; 93; 54; 75; 36; 19; 43; 93; 5; 16; 28; 84; 17; 44; 11; 96; 73; 37; 54; 92; 79; 56; 58; 33; 82; 67; 44; 82; 41; 83; 55; 42; 16; 46] 75)
+
+let test8 _ = assert_equal 1530 (maximizeSum [47; 16; 81; 75; 82; 87; 11; 52; 71; 8; 61; 31; 52; 38; 55; 74; 89; 15; 9; 49; 48; 87; 36; 84; 45; 77; 92; 24; 37; 64; 40; 29; 18; 87; 95; 80; 41; 84; 12; 76; 75; 90; 13; 65; 84] 15)
+
+let test9 _ = assert_equal 500 (maximizeSum [98; 56; 51; 95; 91; 66; 51; 40; 34; 51; 7; 48; 37; 61] 5)
+
+let test10 _ = assert_equal 10200 (maximizeSum [70; 63; 30; 79; 46; 21; 18; 4; 3; 90; 10; 4; 66; 49; 80; 59; 44; 75; 22; 80; 14; 26; 52; 13; 1; 45; 94; 34; 18; 64; 64; 99; 46; 77; 4; 16; 98; 26; 21; 28; 94; 97; 96; 64; 55; 17; 43; 50; 88; 36; 92; 81; 9; 46; 64; 98; 52; 52; 90; 71; 83; 14; 55; 29; 58; 79; 24; 98; 9; 3; 21; 61; 46; 83; 52; 79; 65; 44; 94; 81; 17; 52; 72; 50; 35; 20; 36; 95; 84] 75)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maximizeSum" >::: [
+        
+  "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_sum_with_exactly_k_elements/scala_tests/MySuite.scala

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

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

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

maximum_tastiness_of_candy_basket/meta.json

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

maximum_tastiness_of_candy_basket/ocaml_tests/main.ml

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

maximum_tastiness_of_candy_basket/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maximumTastiness(List(13,5,1,8,21,2),3), 8)
+  }
+
+  test("test2") {
+    assertEquals(Main.maximumTastiness(List(1,3,1),2), 2)
+  }
+
+  test("test3") {
+    assertEquals(Main.maximumTastiness(List(7,7,7,7),2), 0)
+  }
+
+}