61a8d6905f485132fab70e578b5ea9f28927f34ecdc560da5fd03258129cca7c

.gitattributes

@@ -181,3 +181,7 @@ maximum_matching_of_players_with_trainers/meta.json filter=lfs diff=lfs merge=lf
 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_number_of_k_divisible_components/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_or/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_points_after_collecting_coins_from_all_nodes/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+maximum_points_after_collecting_coins_from_all_nodes/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_points_after_collecting_coins_from_all_nodes/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text

maximum_number_of_points_from_grid_queries/java_tests/Main.java

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

maximum_number_of_points_from_grid_queries/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2588,
+    "name": "maximum_number_of_points_from_grid_queries",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/maximum-number-of-points-from-grid-queries/",
+    "date": "1670112000000",
+    "task_description": "You are given an `m x n` integer matrix `grid` and an array `queries` of size `k`. Find an array `answer` of size `k` such that for each integer `queries[i]` you start in the **top left** cell of the matrix and repeat the following process: If `queries[i]` is **strictly** greater than the value of the current cell that you are in, then you get one point if it is your first time visiting this cell, and you can move to any **adjacent** cell in all `4` directions: up, down, left, and right. Otherwise, you do not get any points, and you end this process. After the process, `answer[i]` is the **maximum** number of points you can get. **Note** that for each query you are allowed to visit the same cell **multiple** times. Return _the resulting array_ `answer`. **Example 1:** ``` **Input:** grid = [[1,2,3],[2,5,7],[3,5,1]], queries = [5,6,2] **Output:** [5,8,1] **Explanation:** The diagrams above show which cells we visit to get points for each query. ``` **Example 2:** ``` **Input:** grid = [[5,2,1],[1,1,2]], queries = [3] **Output:** [0] **Explanation:** We can not get any points because the value of the top left cell is already greater than or equal to 3. ``` **Constraints:** `m == grid.length` `n == grid[i].length` `2 <= m, n <= 1000` `4 <= m * n <= 105` `k == queries.length` `1 <= k <= 104` `1 <= grid[i][j], queries[i] <= 106`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "grid = [[1,2,3],[2,5,7],[3,5,1]], queries = [5,6,2]",
+            "output": "[5,8,1] "
+        },
+        {
+            "label": "Example 2",
+            "input": "grid = [[5,2,1],[1,1,2]], queries = [3]",
+            "output": "[0] "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "maxPoints :: [[Int]] -> [Int] -> [Int]\nmaxPoints grid queries ",
+    "ocaml_template": "let maxPoints (grid: int list list) (queries: int list) : int list =  ",
+    "scala_template": "def maxPoints(grid: List[List[Int]],queries: List[Int]): List[Int] = { \n    \n}",
+    "java_template": "public static List<Integer> maxPoints(List<List<Integer>> grid, List<Integer> queries) {\n\n}",
+    "python_template": "class Solution(object):\n    def maxPoints(self, grid, queries):\n        \"\"\"\n        :type grid: List[List[int]]\n        :type queries: List[int]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

maximum_number_of_points_from_grid_queries/ocaml_tests/main.ml

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

maximum_number_of_points_from_grid_queries/scala_tests/MySuite.scala

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

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

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

maximum_number_of_robots_within_budget/meta.json

@@ -0,0 +1,749 @@
+{
+    "id": 2449,
+    "name": "maximum_number_of_robots_within_budget",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/maximum-number-of-robots-within-budget/",
+    "date": "1660953600000",
+    "task_description": "You have `n` robots. You are given two **0-indexed** integer arrays, `chargeTimes` and `runningCosts`, both of length `n`. The `ith` robot costs `chargeTimes[i]` units to charge and costs `runningCosts[i]` units to run. You are also given an integer `budget`. The **total cost** of running `k` chosen robots is equal to `max(chargeTimes) + k * sum(runningCosts)`, where `max(chargeTimes)` is the largest charge cost among the `k` robots and `sum(runningCosts)` is the sum of running costs among the `k` robots. Return_ the **maximum** number of **consecutive** robots you can run such that the total cost **does not** exceed _`budget`. **Example 1:** ``` **Input:** chargeTimes = [3,6,1,3,4], runningCosts = [2,1,3,4,5], budget = 25 **Output:** 3 **Explanation:** It is possible to run all individual and consecutive pairs of robots within budget. To obtain answer 3, consider the first 3 robots. The total cost will be max(3,6,1) + 3 * sum(2,1,3) = 6 + 3 * 6 = 24 which is less than 25. It can be shown that it is not possible to run more than 3 consecutive robots within budget, so we return 3. ``` **Example 2:** ``` **Input:** chargeTimes = [11,12,19], runningCosts = [10,8,7], budget = 19 **Output:** 0 **Explanation:** No robot can be run that does not exceed the budget, so we return 0. ``` **Constraints:** `chargeTimes.length == runningCosts.length == n` `1 <= n <= 5 * 104` `1 <= chargeTimes[i], runningCosts[i] <= 105` `1 <= budget <= 1015`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "chargeTimes = [3,6,1,3,4], runningCosts = [2,1,3,4,5], budget = 25",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "chargeTimes = [11,12,19], runningCosts = [10,8,7], budget = 19",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    60,
+                    57,
+                    78,
+                    28,
+                    25,
+                    31,
+                    65,
+                    53,
+                    67,
+                    1,
+                    46,
+                    99,
+                    58,
+                    3,
+                    93,
+                    8,
+                    21,
+                    23,
+                    58,
+                    2,
+                    21,
+                    96,
+                    37,
+                    74,
+                    100,
+                    6,
+                    61,
+                    86,
+                    19,
+                    41,
+                    71,
+                    37,
+                    59,
+                    51,
+                    52,
+                    96,
+                    65,
+                    60,
+                    92,
+                    64,
+                    79,
+                    49,
+                    19,
+                    77,
+                    30,
+                    40,
+                    22,
+                    68,
+                    100,
+                    75
+                ],
+                [
+                    64,
+                    76,
+                    57,
+                    23,
+                    11,
+                    47,
+                    81,
+                    12,
+                    98,
+                    39,
+                    58,
+                    87,
+                    61,
+                    46,
+                    84,
+                    87,
+                    31,
+                    19,
+                    77,
+                    85,
+                    74,
+                    59,
+                    68,
+                    93,
+                    69,
+                    44,
+                    88,
+                    33,
+                    64,
+                    11,
+                    3,
+                    30,
+                    75,
+                    78,
+                    1,
+                    38,
+                    38,
+                    43,
+                    45,
+                    91,
+                    49,
+                    98,
+                    24,
+                    93,
+                    26,
+                    12,
+                    54,
+                    40,
+                    78,
+                    50
+                ],
+                210870090785272
+            ],
+            "output": 50
+        },
+        {
+            "input": [
+                [
+                    55,
+                    91,
+                    84,
+                    85,
+                    85,
+                    68,
+                    46,
+                    32,
+                    55,
+                    3,
+                    64,
+                    50,
+                    80,
+                    75,
+                    66,
+                    81,
+                    29
+                ],
+                [
+                    69,
+                    82,
+                    4,
+                    13,
+                    97,
+                    97,
+                    50,
+                    44,
+                    20,
+                    93,
+                    65,
+                    50,
+                    9,
+                    67,
+                    100,
+                    95,
+                    31
+                ],
+                501158905863573
+            ],
+            "output": 17
+        },
+        {
+            "input": [
+                [
+                    68,
+                    14,
+                    1,
+                    56,
+                    93,
+                    41,
+                    32,
+                    30,
+                    24,
+                    22,
+                    67,
+                    70,
+                    76,
+                    74,
+                    43,
+                    55,
+                    36,
+                    78,
+                    33,
+                    53,
+                    50,
+                    87,
+                    91,
+                    40,
+                    37,
+                    94,
+                    92,
+                    75,
+                    4,
+                    90,
+                    61,
+                    22,
+                    96,
+                    42,
+                    58,
+                    63,
+                    68,
+                    96,
+                    6,
+                    21,
+                    28,
+                    71
+                ],
+                [
+                    85,
+                    28,
+                    34,
+                    85,
+                    10,
+                    20,
+                    100,
+                    80,
+                    89,
+                    82,
+                    65,
+                    3,
+                    39,
+                    13,
+                    44,
+                    90,
+                    64,
+                    10,
+                    96,
+                    73,
+                    88,
+                    60,
+                    70,
+                    72,
+                    46,
+                    86,
+                    11,
+                    63,
+                    64,
+                    44,
+                    83,
+                    25,
+                    92,
+                    83,
+                    12,
+                    36,
+                    33,
+                    8,
+                    18,
+                    84,
+                    54,
+                    74
+                ],
+                37288282987591
+            ],
+            "output": 42
+        },
+        {
+            "input": [
+                [
+                    12,
+                    89,
+                    12,
+                    9,
+                    36,
+                    92,
+                    93,
+                    88,
+                    30,
+                    98,
+                    6,
+                    3,
+                    52,
+                    30,
+                    50,
+                    41,
+                    12,
+                    6,
+                    41,
+                    51,
+                    79,
+                    56,
+                    27,
+                    97,
+                    99,
+                    54,
+                    6,
+                    55,
+                    42,
+                    50,
+                    74,
+                    51,
+                    27,
+                    85,
+                    97,
+                    68,
+                    71,
+                    10,
+                    46,
+                    72,
+                    62,
+                    99,
+                    30,
+                    6,
+                    21
+                ],
+                [
+                    27,
+                    39,
+                    69,
+                    1,
+                    9,
+                    79,
+                    28,
+                    16,
+                    15,
+                    24,
+                    82,
+                    46,
+                    29,
+                    47,
+                    71,
+                    95,
+                    45,
+                    48,
+                    92,
+                    64,
+                    10,
+                    47,
+                    46,
+                    3,
+                    27,
+                    94,
+                    51,
+                    84,
+                    70,
+                    99,
+                    67,
+                    88,
+                    70,
+                    11,
+                    54,
+                    61,
+                    98,
+                    54,
+                    23,
+                    41,
+                    17,
+                    64,
+                    13,
+                    5,
+                    68
+                ],
+                100631638339804
+            ],
+            "output": 45
+        },
+        {
+            "input": [
+                [
+                    92,
+                    34,
+                    85,
+                    61,
+                    54,
+                    41,
+                    27,
+                    35,
+                    49,
+                    86,
+                    61,
+                    36,
+                    4,
+                    79,
+                    65,
+                    40,
+                    46,
+                    60,
+                    19,
+                    18,
+                    71,
+                    72,
+                    8,
+                    9,
+                    56,
+                    65,
+                    96,
+                    64,
+                    52,
+                    12,
+                    3,
+                    9,
+                    44
+                ],
+                [
+                    99,
+                    78,
+                    48,
+                    30,
+                    37,
+                    70,
+                    70,
+                    86,
+                    56,
+                    46,
+                    62,
+                    90,
+                    85,
+                    93,
+                    87,
+                    75,
+                    63,
+                    14,
+                    78,
+                    28,
+                    31,
+                    35,
+                    82,
+                    82,
+                    29,
+                    35,
+                    72,
+                    58,
+                    52,
+                    21,
+                    47,
+                    72,
+                    47
+                ],
+                424239692664293
+            ],
+            "output": 33
+        },
+        {
+            "input": [
+                [
+                    95,
+                    66,
+                    39,
+                    93,
+                    90,
+                    98,
+                    47,
+                    94,
+                    62,
+                    30,
+                    19,
+                    49,
+                    55,
+                    98,
+                    87,
+                    64,
+                    63,
+                    60,
+                    31,
+                    28,
+                    64,
+                    77,
+                    79,
+                    91,
+                    29,
+                    61,
+                    70,
+                    71,
+                    11,
+                    35,
+                    64,
+                    87,
+                    46,
+                    28,
+                    17,
+                    44
+                ],
+                [
+                    74,
+                    2,
+                    58,
+                    52,
+                    21,
+                    72,
+                    43,
+                    37,
+                    9,
+                    1,
+                    88,
+                    38,
+                    97,
+                    38,
+                    61,
+                    38,
+                    61,
+                    22,
+                    75,
+                    21,
+                    31,
+                    58,
+                    58,
+                    87,
+                    16,
+                    1,
+                    16,
+                    56,
+                    11,
+                    60,
+                    2,
+                    91,
+                    9,
+                    37,
+                    68,
+                    10
+                ],
+                228180887669616
+            ],
+            "output": 36
+        },
+        {
+            "input": [
+                [
+                    23,
+                    73,
+                    21,
+                    71,
+                    55,
+                    59,
+                    9,
+                    78,
+                    50,
+                    58,
+                    30,
+                    10,
+                    75,
+                    65,
+                    82,
+                    24,
+                    23,
+                    43,
+                    58,
+                    100,
+                    65,
+                    86,
+                    10,
+                    86
+                ],
+                [
+                    81,
+                    63,
+                    54,
+                    22,
+                    22,
+                    1,
+                    32,
+                    26,
+                    73,
+                    59,
+                    21,
+                    57,
+                    6,
+                    52,
+                    25,
+                    75,
+                    38,
+                    37,
+                    8,
+                    98,
+                    39,
+                    52,
+                    50,
+                    33
+                ],
+                358813912220824
+            ],
+            "output": 24
+        },
+        {
+            "input": [
+                [
+                    91,
+                    87,
+                    87,
+                    63,
+                    19,
+                    91,
+                    74,
+                    91,
+                    62,
+                    96,
+                    85,
+                    86,
+                    12,
+                    2,
+                    16,
+                    65,
+                    84,
+                    92,
+                    5,
+                    88,
+                    32,
+                    28,
+                    61,
+                    3,
+                    8,
+                    95
+                ],
+                [
+                    67,
+                    78,
+                    78,
+                    74,
+                    9,
+                    48,
+                    94,
+                    76,
+                    98,
+                    14,
+                    17,
+                    50,
+                    39,
+                    72,
+                    98,
+                    84,
+                    67,
+                    42,
+                    8,
+                    1,
+                    25,
+                    89,
+                    46,
+                    45,
+                    63,
+                    36
+                ],
+                372085360977557
+            ],
+            "output": 26
+        },
+        {
+            "input": [
+                [
+                    21,
+                    73,
+                    14,
+                    68,
+                    100,
+                    83,
+                    91,
+                    81,
+                    72,
+                    24,
+                    61
+                ],
+                [
+                    65,
+                    98,
+                    78,
+                    84,
+                    2,
+                    64,
+                    88,
+                    18,
+                    30,
+                    88,
+                    57
+                ],
+                275993940081086
+            ],
+            "output": 11
+        },
+        {
+            "input": [
+                [
+                    55,
+                    9,
+                    13,
+                    100,
+                    30,
+                    6,
+                    42,
+                    83,
+                    66,
+                    18,
+                    40,
+                    24,
+                    99,
+                    46,
+                    26,
+                    74,
+                    89,
+                    58,
+                    14,
+                    90,
+                    27,
+                    76,
+                    50,
+                    31,
+                    96,
+                    62,
+                    20
+                ],
+                [
+                    70,
+                    7,
+                    59,
+                    97,
+                    77,
+                    57,
+                    25,
+                    3,
+                    84,
+                    24,
+                    47,
+                    1,
+                    33,
+                    81,
+                    74,
+                    53,
+                    46,
+                    41,
+                    7,
+                    72,
+                    8,
+                    59,
+                    17,
+                    3,
+                    63,
+                    80,
+                    87
+                ],
+                89438979818988
+            ],
+            "output": 27
+        }
+    ],
+    "haskell_template": "maximumRobots :: [Int] -> [Int] -> Int -> Int\nmaximumRobots chargeTimes runningCosts budget ",
+    "ocaml_template": "let maximumRobots (chargeTimes: int list) (runningCosts: int list) (budget: int) : int =  ",
+    "scala_template": "def maximumRobots(chargeTimes: List[Int],runningCosts: List[Int],budget: Int): Int = { \n    \n}",
+    "java_template": "public static int maximumRobots(List<Integer> chargeTimes, List<Integer> runningCosts, int budget) {\n\n}",
+    "python_template": "class Solution(object):\n    def maximumRobots(self, chargeTimes, runningCosts, budget):\n        \"\"\"\n        :type chargeTimes: List[int]\n        :type runningCosts: List[int]\n        :type budget: int\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_number_of_robots_within_budget/ocaml_tests/main.ml

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

maximum_number_of_robots_within_budget/scala_tests/MySuite.scala

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

maximum_number_that_sum_of_the_prices_is_less_than_or_equal_to_k/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 (findMaximumNumber 9 1)," 6 (findMaximumNumber 9 1))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findMaximumNumber 7 2)," 9 (findMaximumNumber 7 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (findMaximumNumber 531872414732251 7)," 177565693781781 (findMaximumNumber 531872414732251 7))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (findMaximumNumber 340835112471797 3)," 46336165184101 (findMaximumNumber 340835112471797 3))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (findMaximumNumber 160343276908028 8)," 64229223168211 (findMaximumNumber 160343276908028 8))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (findMaximumNumber 676716706602279 5)," 151604230490636 (findMaximumNumber 676716706602279 5))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (findMaximumNumber 671134782855633 8)," 231967802093764 (findMaximumNumber 671134782855633 8))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (findMaximumNumber 283099675489092 1)," 13082354738495 (findMaximumNumber 283099675489092 1))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (findMaximumNumber 844018400796959 4)," 152008536869498 (findMaximumNumber 844018400796959 4))
+
+
+-- 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_number_that_sum_of_the_prices_is_less_than_or_equal_to_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(6, findMaximumNumber(9, 1));
+}
+@Test
+public void test2() {
+    assertEquals(9, findMaximumNumber(7, 2));
+}
+
+}

maximum_number_that_sum_of_the_prices_is_less_than_or_equal_to_k/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3240,
+    "name": "maximum_number_that_sum_of_the_prices_is_less_than_or_equal_to_k",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k/",
+    "date": "2024-01-07 00:00:00",
+    "task_description": "You are given an integer `k` and an integer `x`. The price of a number `num` is calculated by the count of set bits at positions `x`, `2x`, `3x`, etc., in its binary representation, starting from the least significant bit. The following table contains examples of how price is calculated. x num Binary Representation Price 1 13 00000**1****1**0**1** 3 2 13 00000**1**101 1 2 233 0**1**1**1**0**1**001 3 3 13 000001**1**01 1 3 362 **1**01**1**01010 2 The **accumulated price** of `num` is the total price of numbers from `1` to `num`. `num` is considered **cheap** if its accumulated price is less than or equal to `k`. Return the greatest cheap number. **Example 1:** **Input:** k = 9, x = 1 **Output:** 6 **Explanation:** As shown in the table below, `6` is the greatest cheap number. x num Binary Representation Price Accumulated Price 1 1 00**1** 1 1 1 2 0**1**0 1 2 1 3 0**1****1** 2 4 1 4 **1**00 1 5 1 5 **1**0**1** 2 7 1 6 **1****1**0 2 9 1 7 **1****1****1** 3 12 **Example 2:** **Input:** k = 7, x = 2 **Output:** 9 **Explanation:** As shown in the table below, `9` is the greatest cheap number. x num Binary Representation Price Accumulated Price 2 1 0001 0 0 2 2 00**1**0 1 1 2 3 00**1**1 1 2 2 4 0100 0 2 2 5 0101 0 2 2 6 01**1**0 1 3 2 7 01**1**1 1 4 2 8 **1**000 1 5 2 9 **1**001 1 6 2 10 **1**0**1**0 2 8 **Constraints:** `1 <= k <= 1015` `1 <= x <= 8`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "k = 9, x = 1",
+            "output": "6 "
+        },
+        {
+            "label": "Example 2",
+            "input": "k = 7, x = 2",
+            "output": "9 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                531872414732251,
+                7
+            ],
+            "output": 177565693781781
+        },
+        {
+            "input": [
+                340835112471797,
+                3
+            ],
+            "output": 46336165184101
+        },
+        {
+            "input": [
+                160343276908028,
+                8
+            ],
+            "output": 64229223168211
+        },
+        {
+            "input": [
+                676716706602279,
+                5
+            ],
+            "output": 151604230490636
+        },
+        {
+            "input": [
+                671134782855633,
+                8
+            ],
+            "output": 231967802093764
+        },
+        {
+            "input": [
+                283099675489092,
+                1
+            ],
+            "output": 13082354738495
+        },
+        {
+            "input": [
+                844018400796959,
+                4
+            ],
+            "output": 152008536869498
+        },
+        {
+            "input": [
+                938778172153246,
+                5
+            ],
+            "output": 208870257401774
+        },
+        {
+            "input": [
+                157598202823467,
+                3
+            ],
+            "output": 21909790975774
+        },
+        {
+            "input": [
+                354416755461206,
+                7
+            ],
+            "output": 118226590889092
+        }
+    ],
+    "haskell_template": "findMaximumNumber :: Int -> Int -> Int\nfindMaximumNumber k x ",
+    "ocaml_template": "let findMaximumNumber (k: int) (x: int) : int =  ",
+    "scala_template": "def findMaximumNumber(k: Int,x: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long findMaximumNumber(long k, int x) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findMaximumNumber(self, k, x):\n        \"\"\"\n        :type k: int\n        :type x: int\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_number_that_sum_of_the_prices_is_less_than_or_equal_to_k/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 6 (findMaximumNumber 9 1)
+
+let test2 _ = assert_equal 9 (findMaximumNumber 7 2)
+
+let test3 _ = assert_equal 177565693781781 (findMaximumNumber 531872414732251 7)
+
+let test4 _ = assert_equal 46336165184101 (findMaximumNumber 340835112471797 3)
+
+let test5 _ = assert_equal 64229223168211 (findMaximumNumber 160343276908028 8)
+
+let test6 _ = assert_equal 151604230490636 (findMaximumNumber 676716706602279 5)
+
+let test7 _ = assert_equal 231967802093764 (findMaximumNumber 671134782855633 8)
+
+let test8 _ = assert_equal 13082354738495 (findMaximumNumber 283099675489092 1)
+
+let test9 _ = assert_equal 152008536869498 (findMaximumNumber 844018400796959 4)
+
+let test10 _ = assert_equal 208870257401774 (findMaximumNumber 938778172153246 5)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for findMaximumNumber" >::: [
+        
+  "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_number_that_sum_of_the_prices_is_less_than_or_equal_to_k/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findMaximumNumber(9,1), 6)
+  }
+
+  test("test2") {
+    assertEquals(Main.findMaximumNumber(7,2), 9)
+  }
+
+  test("test3") {
+    assertEquals(Main.findMaximumNumber(BigInt("531872414732251"),7), BigInt("177565693781781"))
+  }
+
+  test("test4") {
+    assertEquals(Main.findMaximumNumber(BigInt("340835112471797"),3), BigInt("46336165184101"))
+  }
+
+  test("test5") {
+    assertEquals(Main.findMaximumNumber(BigInt("160343276908028"),8), BigInt("64229223168211"))
+  }
+
+  test("test6") {
+    assertEquals(Main.findMaximumNumber(BigInt("676716706602279"),5), BigInt("151604230490636"))
+  }
+
+  test("test7") {
+    assertEquals(Main.findMaximumNumber(BigInt("671134782855633"),8), BigInt("231967802093764"))
+  }
+
+  test("test8") {
+    assertEquals(Main.findMaximumNumber(BigInt("283099675489092"),1), BigInt("13082354738495"))
+  }
+
+  test("test9") {
+    assertEquals(Main.findMaximumNumber(BigInt("844018400796959"),4), BigInt("152008536869498"))
+  }
+
+  test("test10") {
+    assertEquals(Main.findMaximumNumber(BigInt("938778172153246"),5), BigInt("208870257401774"))
+  }
+
+}

maximum_odd_binary_number/haskell_tests/Main.hs

@@ -0,0 +1,47 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+maximumOddBinaryNumber :: String -> String
+maximumOddBinaryNumber s = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maximumOddBinaryNumber \"010 \")," "001" (maximumOddBinaryNumber "010"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maximumOddBinaryNumber \"0101 \")," "1001" (maximumOddBinaryNumber "0101"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maximumOddBinaryNumber  \"100110100001001110100010000011110000001011010001110100100110000010100011110011000111010 \")," "111111111111111111111111111111111111000000000000000000000000000000000000000000000000001" (maximumOddBinaryNumber "100110100001001110100010000011110000001011010001110100100110000010100011110011000111010"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (maximumOddBinaryNumber  \"0000000001100111000000111010101110111111011101010010100001101100010001111000101100100000111001 \")," "1111111111111111111111111111111111111111110000000000000000000000000000000000000000000000000001" (maximumOddBinaryNumber "0000000001100111000000111010101110111111011101010010100001101100010001111000101100100000111001"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (maximumOddBinaryNumber  \"001110000001101101100011010011110011001011101110010001000111011010110011001 \")," "111111111111111111111111111111111111100000000000000000000000000000000000001" (maximumOddBinaryNumber "001110000001101101100011010011110011001011101110010001000111011010110011001"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (maximumOddBinaryNumber  \"0011010100000101010100000011101000101010000100101110101100011111010000101110110100 \")," "1111111111111111111111111111111111100000000000000000000000000000000000000000000001" (maximumOddBinaryNumber "0011010100000101010100000011101000101010000100101110101100011111010000101110110100"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (maximumOddBinaryNumber  \"10111100110111000111000001111100 \")," "11111111111111111000000000000001" (maximumOddBinaryNumber "10111100110111000111000001111100"))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (maximumOddBinaryNumber  \"101110000001000001011111101000100010010001101011101100011101100 \")," "111111111111111111111111111100000000000000000000000000000000001" (maximumOddBinaryNumber "101110000001000001011111101000100010010001101011101100011101100"))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (maximumOddBinaryNumber  \"11101111000110011100110101101011101100101000011000001111111100000011100001 \")," "11111111111111111111111111111111111111000000000000000000000000000000000001" (maximumOddBinaryNumber "11101111000110011100110101101011101100101000011000001111111100000011100001"))
+
+
+-- 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_odd_binary_number/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("010", maximumOddBinaryNumber("010"));
+}
+@Test
+public void test2() {
+    assertEquals("0101", maximumOddBinaryNumber("0101"));
+}
+
+}

maximum_odd_binary_number/meta.json

@@ -0,0 +1,67 @@
+{
+    "id": 3055,
+    "name": "maximum_odd_binary_number",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/maximum-odd-binary-number/",
+    "date": "2023-09-17 00:00:00",
+    "task_description": "You are given a **binary** string `s` that contains at least one `'1'`. You have to **rearrange** the bits in such a way that the resulting binary number is the **maximum odd binary number** that can be created from this combination. Return _a string representing the maximum odd binary number that can be created from the given combination._ **Note **that the resulting string **can** have leading zeros. **Example 1:** ``` **Input:** s = \"010\" **Output:** \"001\" **Explanation:** Because there is just one '1', it must be in the last position. So the answer is \"001\". ``` **Example 2:** ``` **Input:** s = \"0101\" **Output:** \"1001\" **Explanation: **One of the '1's must be in the last position. The maximum number that can be made with the remaining digits is \"100\". So the answer is \"1001\". ``` **Constraints:** `1 <= s.length <= 100` `s` consists only of `'0'` and `'1'`. `s` contains at least one `'1'`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"010\"",
+            "output": "\"001\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"0101\"",
+            "output": "\"1001\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "100110100001001110100010000011110000001011010001110100100110000010100011110011000111010",
+            "output": "111111111111111111111111111111111111000000000000000000000000000000000000000000000000001"
+        },
+        {
+            "input": "0000000001100111000000111010101110111111011101010010100001101100010001111000101100100000111001",
+            "output": "1111111111111111111111111111111111111111110000000000000000000000000000000000000000000000000001"
+        },
+        {
+            "input": "001110000001101101100011010011110011001011101110010001000111011010110011001",
+            "output": "111111111111111111111111111111111111100000000000000000000000000000000000001"
+        },
+        {
+            "input": "0011010100000101010100000011101000101010000100101110101100011111010000101110110100",
+            "output": "1111111111111111111111111111111111100000000000000000000000000000000000000000000001"
+        },
+        {
+            "input": "10111100110111000111000001111100",
+            "output": "11111111111111111000000000000001"
+        },
+        {
+            "input": "101110000001000001011111101000100010010001101011101100011101100",
+            "output": "111111111111111111111111111100000000000000000000000000000000001"
+        },
+        {
+            "input": "11101111000110011100110101101011101100101000011000001111111100000011100001",
+            "output": "11111111111111111111111111111111111111000000000000000000000000000000000001"
+        },
+        {
+            "input": "01010100101010110010000011101111010001001110010100000111001110110",
+            "output": "11111111111111111111111111111100000000000000000000000000000000001"
+        },
+        {
+            "input": "011111110",
+            "output": "111111001"
+        },
+        {
+            "input": "111011010110101001010100001111100010101100000100110011001",
+            "output": "111111111111111111111111111000000000000000000000000000001"
+        }
+    ],
+    "haskell_template": "maximumOddBinaryNumber :: String -> String\nmaximumOddBinaryNumber s ",
+    "ocaml_template": "let maximumOddBinaryNumber (s: string) : string =  ",
+    "scala_template": "def maximumOddBinaryNumber(s: String): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String maximumOddBinaryNumber(String s) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def maximumOddBinaryNumber(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: str\n        \"\"\"\n        "
+}

maximum_odd_binary_number/ocaml_tests/main.ml

@@ -0,0 +1,51 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let maximumOddBinaryNumber (s: string) : string =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "001" (maximumOddBinaryNumber "010")
+
+let test2 _ = assert_equal "1001" (maximumOddBinaryNumber "0101")
+
+let test3 _ = assert_equal "1001" (maximumOddBinaryNumber "100110100001001110100010000011110000001011010001110100100110000010100011110011000111010")
+
+let test4 _ = assert_equal "1001" (maximumOddBinaryNumber "0000000001100111000000111010101110111111011101010010100001101100010001111000101100100000111001")
+
+let test5 _ = assert_equal "1001" (maximumOddBinaryNumber "001110000001101101100011010011110011001011101110010001000111011010110011001")
+
+let test6 _ = assert_equal "1001" (maximumOddBinaryNumber "0011010100000101010100000011101000101010000100101110101100011111010000101110110100")
+
+let test7 _ = assert_equal "1001" (maximumOddBinaryNumber "10111100110111000111000001111100")
+
+let test8 _ = assert_equal "1001" (maximumOddBinaryNumber "101110000001000001011111101000100010010001101011101100011101100")
+
+let test9 _ = assert_equal "1001" (maximumOddBinaryNumber "11101111000110011100110101101011101100101000011000001111111100000011100001")
+
+let test10 _ = assert_equal "1001" (maximumOddBinaryNumber "01010100101010110010000011101111010001001110010100000111001110110")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maximumOddBinaryNumber" >::: [
+        
+  "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_odd_binary_number/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maximumOddBinaryNumber("010"), "001")
+  }
+
+  test("test2") {
+    assertEquals(Main.maximumOddBinaryNumber("0101"), "1001")
+  }
+
+  test("test3") {
+    assertEquals(Main.maximumOddBinaryNumber(",1,0,0,1,1,0,1,0,0,0,0,1,0,0,1,1,1,0,1,0,0,0,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,0,1,1,0,1,0,0,0,1,1,1,0,1,0,0,1,0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,1,1,1,0,1,0,"), "111111111111111111111111111111111111000000000000000000000000000000000000000000000000001")
+  }
+
+  test("test4") {
+    assertEquals(Main.maximumOddBinaryNumber(",0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,1,0,1,0,1,1,1,0,1,1,1,1,1,1,0,1,1,1,0,1,0,1,0,0,1,0,1,0,0,0,0,1,1,0,1,1,0,0,0,1,0,0,0,1,1,1,1,0,0,0,1,0,1,1,0,0,1,0,0,0,0,0,1,1,1,0,0,1,"), "1111111111111111111111111111111111111111110000000000000000000000000000000000000000000000000001")
+  }
+
+  test("test5") {
+    assertEquals(Main.maximumOddBinaryNumber(",0,0,1,1,1,0,0,0,0,0,0,1,1,0,1,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,1,1,0,0,1,1,0,0,1,0,1,1,1,0,1,1,1,0,0,1,0,0,0,1,0,0,0,1,1,1,0,1,1,0,1,0,1,1,0,0,1,1,0,0,1,"), "111111111111111111111111111111111111100000000000000000000000000000000000001")
+  }
+
+  test("test6") {
+    assertEquals(Main.maximumOddBinaryNumber(",0,0,1,1,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,0,1,1,1,0,1,0,0,0,1,0,1,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,1,0,1,1,0,0,0,1,1,1,1,1,0,1,0,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,"), "1111111111111111111111111111111111100000000000000000000000000000000000000000000001")
+  }
+
+  test("test7") {
+    assertEquals(Main.maximumOddBinaryNumber(",1,0,1,1,1,1,0,0,1,1,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,0,0,"), "11111111111111111000000000000001")
+  }
+
+  test("test8") {
+    assertEquals(Main.maximumOddBinaryNumber(",1,0,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,1,1,1,1,1,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,1,0,1,0,1,1,1,0,1,1,0,0,0,1,1,1,0,1,1,0,0,"), "111111111111111111111111111100000000000000000000000000000000001")
+  }
+
+  test("test9") {
+    assertEquals(Main.maximumOddBinaryNumber(",1,1,1,0,1,1,1,1,0,0,0,1,1,0,0,1,1,1,0,0,1,1,0,1,0,1,1,0,1,0,1,1,1,0,1,1,0,0,1,0,1,0,0,0,0,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,"), "11111111111111111111111111111111111111000000000000000000000000000000000001")
+  }
+
+  test("test10") {
+    assertEquals(Main.maximumOddBinaryNumber(",0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,0,1,1,1,0,1,1,1,1,0,1,0,0,0,1,0,0,1,1,1,0,0,1,0,1,0,0,0,0,0,1,1,1,0,0,1,1,1,0,1,1,0,"), "11111111111111111111111111111100000000000000000000000000000000001")
+  }
+
+}

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

maximum_or/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, maximumOr(new ArrayList<>(Arrays.asList(12,9)), 1));
+}
+@Test
+public void test2() {
+    assertEquals(35, maximumOr(new ArrayList<>(Arrays.asList(8,1,2)), 2));
+}
+
+}

maximum_or/meta.json

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

maximum_or/ocaml_tests/main.ml

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

maximum_or/scala_tests/MySuite.scala

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

maximum_palindromes_after_operations/java_tests/Main.java

@@ -0,0 +1,24 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(3, maxPalindromesAfterOperations(Arrays.asList("abbb","ba","aa")));
+}
+@Test
+public void test2() {
+    assertEquals(2, maxPalindromesAfterOperations(Arrays.asList("abc","ab")));
+}
+@Test
+public void test3() {
+    assertEquals(1, maxPalindromesAfterOperations(Arrays.asList("cd","ef","a")));
+}
+
+}

maximum_points_after_collecting_coins_from_all_nodes/haskell_tests/Main.hs

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

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

maximum_points_after_collecting_coins_from_all_nodes/meta.json

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

maximum_points_after_collecting_coins_from_all_nodes/scala_tests/MySuite.scala

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

maximum_points_after_enemy_battles/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, maximumPoints(new ArrayList<>(Arrays.asList(3,2,2)), 2));
+}
+@Test
+public void test2() {
+    assertEquals(5, maximumPoints(null, 10));
+}
+
+}

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

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

maximum_points_in_an_archery_competition/meta.json

@@ -0,0 +1,357 @@
+{
+    "id": 2318,
+    "name": "maximum_points_in_an_archery_competition",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/maximum-points-in-an-archery-competition/",
+    "date": "1647129600000",
+    "task_description": "Alice and Bob are opponents in an archery competition. The competition has set the following rules: Alice first shoots `numArrows` arrows and then Bob shoots `numArrows` arrows. The points are then calculated as follows: The target has integer scoring sections ranging from `0` to `11` **inclusive**. For **each** section of the target with score `k` (in between `0` to `11`), say Alice and Bob have shot `ak` and `bk` arrows on that section respectively. If `ak >= bk`, then Alice takes `k` points. If `ak < bk`, then Bob takes `k` points. However, if `ak == bk == 0`, then **nobody** takes `k` points. For example, if Alice and Bob both shot `2` arrows on the section with score `11`, then Alice takes `11` points. On the other hand, if Alice shot `0` arrows on the section with score `11` and Bob shot `2` arrows on that same section, then Bob takes `11` points. You are given the integer `numArrows` and an integer array `aliceArrows` of size `12`, which represents the number of arrows Alice shot on each scoring section from `0` to `11`. Now, Bob wants to **maximize** the total number of points he can obtain. Return _the array _`bobArrows`_ which represents the number of arrows Bob shot on **each** scoring section from _`0`_ to _`11`. The sum of the values in `bobArrows` should equal `numArrows`. If there are multiple ways for Bob to earn the maximum total points, return **any** one of them. **Example 1:** ``` **Input:** numArrows = 9, aliceArrows = [1,1,0,1,0,0,2,1,0,1,2,0] **Output:** [0,0,0,0,1,1,0,0,1,2,3,1] **Explanation:** The table above shows how the competition is scored. Bob earns a total point of 4 + 5 + 8 + 9 + 10 + 11 = 47. It can be shown that Bob cannot obtain a score higher than 47 points. ``` **Example 2:** ``` **Input:** numArrows = 3, aliceArrows = [0,0,1,0,0,0,0,0,0,0,0,2] **Output:** [0,0,0,0,0,0,0,0,1,1,1,0] **Explanation:** The table above shows how the competition is scored. Bob earns a total point of 8 + 9 + 10 = 27. It can be shown that Bob cannot obtain a score higher than 27 points. ``` **Constraints:** `1 <= numArrows <= 105` `aliceArrows.length == bobArrows.length == 12` `0 <= aliceArrows[i], bobArrows[i] <= numArrows` `sum(aliceArrows[i]) == numArrows`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "numArrows = 9, aliceArrows = [1,1,0,1,0,0,2,1,0,1,2,0]",
+            "output": "[0,0,0,0,1,1,0,0,1,2,3,1] "
+        },
+        {
+            "label": "Example 2",
+            "input": "numArrows = 3, aliceArrows = [0,0,1,0,0,0,0,0,0,0,0,2]",
+            "output": "[0,0,0,0,0,0,0,0,1,1,1,0] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                7327,
+                [
+                    5024,
+                    1281,
+                    875,
+                    79,
+                    22,
+                    6,
+                    30,
+                    5,
+                    3,
+                    0,
+                    0,
+                    2
+                ]
+            ],
+            "output": [
+                0,
+                1282,
+                876,
+                80,
+                23,
+                7,
+                31,
+                6,
+                4,
+                1,
+                1,
+                5016
+            ]
+        },
+        {
+            "input": [
+                21169,
+                [
+                    11398,
+                    8048,
+                    894,
+                    239,
+                    173,
+                    284,
+                    78,
+                    28,
+                    5,
+                    21,
+                    0,
+                    1
+                ]
+            ],
+            "output": [
+                0,
+                8049,
+                895,
+                240,
+                174,
+                285,
+                79,
+                29,
+                6,
+                22,
+                1,
+                11389
+            ]
+        },
+        {
+            "input": [
+                92215,
+                [
+                    90650,
+                    1305,
+                    215,
+                    2,
+                    38,
+                    4,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0
+                ]
+            ],
+            "output": [
+                0,
+                1306,
+                216,
+                3,
+                39,
+                5,
+                2,
+                1,
+                1,
+                1,
+                1,
+                90640
+            ]
+        },
+        {
+            "input": [
+                21066,
+                [
+                    2883,
+                    10299,
+                    1763,
+                    2010,
+                    1435,
+                    1608,
+                    572,
+                    93,
+                    119,
+                    153,
+                    71,
+                    60
+                ]
+            ],
+            "output": [
+                0,
+                10300,
+                1764,
+                2011,
+                1436,
+                1609,
+                573,
+                94,
+                120,
+                154,
+                72,
+                2933
+            ]
+        },
+        {
+            "input": [
+                15410,
+                [
+                    12135,
+                    1876,
+                    1186,
+                    31,
+                    77,
+                    33,
+                    62,
+                    10,
+                    0,
+                    0,
+                    0,
+                    0
+                ]
+            ],
+            "output": [
+                0,
+                1877,
+                1187,
+                32,
+                78,
+                34,
+                63,
+                11,
+                1,
+                1,
+                1,
+                12125
+            ]
+        },
+        {
+            "input": [
+                76447,
+                [
+                    69211,
+                    6849,
+                    289,
+                    52,
+                    44,
+                    0,
+                    0,
+                    1,
+                    1,
+                    0,
+                    0,
+                    0
+                ]
+            ],
+            "output": [
+                0,
+                6850,
+                290,
+                53,
+                45,
+                1,
+                1,
+                2,
+                2,
+                1,
+                1,
+                69201
+            ]
+        },
+        {
+            "input": [
+                54503,
+                [
+                    16589,
+                    9581,
+                    11400,
+                    12064,
+                    1543,
+                    3205,
+                    45,
+                    3,
+                    47,
+                    10,
+                    14,
+                    2
+                ]
+            ],
+            "output": [
+                0,
+                9582,
+                11401,
+                12065,
+                1544,
+                3206,
+                46,
+                4,
+                48,
+                11,
+                15,
+                16581
+            ]
+        },
+        {
+            "input": [
+                76989,
+                [
+                    1045,
+                    46635,
+                    11368,
+                    257,
+                    7394,
+                    1874,
+                    1433,
+                    2922,
+                    2958,
+                    1101,
+                    0,
+                    2
+                ]
+            ],
+            "output": [
+                0,
+                46636,
+                11369,
+                258,
+                7395,
+                1875,
+                1434,
+                2923,
+                2959,
+                1102,
+                1,
+                1037
+            ]
+        },
+        {
+            "input": [
+                59368,
+                [
+                    58960,
+                    239,
+                    38,
+                    61,
+                    29,
+                    34,
+                    3,
+                    3,
+                    0,
+                    0,
+                    0,
+                    1
+                ]
+            ],
+            "output": [
+                0,
+                240,
+                39,
+                62,
+                30,
+                35,
+                4,
+                4,
+                1,
+                1,
+                1,
+                58951
+            ]
+        },
+        {
+            "input": [
+                69273,
+                [
+                    59439,
+                    6843,
+                    2852,
+                    73,
+                    66,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0
+                ]
+            ],
+            "output": [
+                0,
+                6844,
+                2853,
+                74,
+                67,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                59429
+            ]
+        }
+    ],
+    "haskell_template": "maximumBobPoints :: Int -> [Int] -> [Int]\nmaximumBobPoints numArrows aliceArrows ",
+    "ocaml_template": "let maximumBobPoints (numArrows: int) (aliceArrows: int list) : int list =  ",
+    "scala_template": "def maximumBobPoints(numArrows: Int,aliceArrows: List[Int]): List[Int] = { \n    \n}",
+    "java_template": "public static List<Integer> maximumBobPoints(int numArrows, List<Integer> aliceArrows) {\n\n}",
+    "python_template": "class Solution(object):\n    def maximumBobPoints(self, numArrows, aliceArrows):\n        \"\"\"\n        :type numArrows: int\n        :type aliceArrows: List[int]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

maximum_points_in_an_archery_competition/ocaml_tests/main.ml

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

maximum_points_in_an_archery_competition/scala_tests/MySuite.scala

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

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