39a8ae557bafed1b5e5736c10b5897d38635ffc981d13fa842f1ce72e4046229

.gitattributes

@@ -61,3 +61,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 add_edges_to_make_degrees_of_all_nodes_even/meta.json filter=lfs diff=lfs merge=lfs -text
 all_divisions_with_the_highest_score_of_a_binary_array/meta.json filter=lfs diff=lfs merge=lfs -text
 alternating_groups_iii/meta.json filter=lfs diff=lfs merge=lfs -text
+append_k_integers_with_minimal_sum/meta.json filter=lfs diff=lfs merge=lfs -text
+apply_operations_on_array_to_maximize_sum_of_squares/meta.json filter=lfs diff=lfs merge=lfs -text
+apply_operations_to_maximize_frequency_score/meta.json filter=lfs diff=lfs merge=lfs -text

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

append_k_integers_with_minimal_sum/java_tests/Main.java

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

append_k_integers_with_minimal_sum/meta.json

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

append_k_integers_with_minimal_sum/ocaml_tests/main.ml

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

append_k_integers_with_minimal_sum/scala_tests/MySuite.scala

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

apple_redistribution_into_boxes/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 (minimumBoxes [1,3,2] [4,3,1,5,2])," 2 (minimumBoxes [1,3,2] [4,3,1,5,2]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumBoxes [5,5,5] [2,4,2,7])," 4 (minimumBoxes [5,5,5] [2,4,2,7]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumBoxes [12, 39, 47, 10, 21, 26, 7, 50] [49, 43, 35, 30, 29, 28, 24, 7])," 6 (minimumBoxes [12, 39, 47, 10, 21, 26, 7, 50] [49, 43, 35, 30, 29, 28, 24, 7]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimumBoxes [35, 48, 40, 16, 43, 36, 41, 4] [46, 45, 45, 44, 43, 40, 38, 38, 36, 34, 34, 33, 30, 29, 28, 26, 25, 24, 22, 22, 19, 18, 17, 7, 2, 2, 2, 1])," 6 (minimumBoxes [35, 48, 40, 16, 43, 36, 41, 4] [46, 45, 45, 44, 43, 40, 38, 38, 36, 34, 34, 33, 30, 29, 28, 26, 25, 24, 22, 22, 19, 18, 17, 7, 2, 2, 2, 1]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimumBoxes [18, 45, 11, 47, 26, 2, 39, 48, 43, 16, 4, 17, 48, 44, 2, 21, 41, 40, 17, 29, 35, 23, 45, 30, 31, 34, 39] [205, 50, 45, 45, 45, 42, 39, 37, 35, 35, 31, 27, 26, 24, 24, 21, 21, 15, 14, 8, 6])," 21 (minimumBoxes [18, 45, 11, 47, 26, 2, 39, 48, 43, 16, 4, 17, 48, 44, 2, 21, 41, 40, 17, 29, 35, 23, 45, 30, 31, 34, 39] [205, 50, 45, 45, 45, 42, 39, 37, 35, 35, 31, 27, 26, 24, 24, 21, 21, 15, 14, 8, 6]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimumBoxes [46, 5, 6, 15, 47, 20, 16, 19, 42, 44, 44, 28, 28, 19, 16, 26, 47, 12, 39, 40, 25, 25, 48, 3, 17, 6, 21, 22, 20, 2, 50, 50, 26, 26, 41, 5, 9, 31, 19, 40, 26] [719, 50, 49, 41, 31, 28, 28, 23, 22, 20, 15, 11, 11, 10, 8, 5])," 16 (minimumBoxes [46, 5, 6, 15, 47, 20, 16, 19, 42, 44, 44, 28, 28, 19, 16, 26, 47, 12, 39, 40, 25, 25, 48, 3, 17, 6, 21, 22, 20, 2, 50, 50, 26, 26, 41, 5, 9, 31, 19, 40, 26] [719, 50, 49, 41, 31, 28, 28, 23, 22, 20, 15, 11, 11, 10, 8, 5]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimumBoxes [14, 12, 1, 27, 27, 29, 14, 12, 7, 6, 8, 42, 34, 42, 44, 46, 27, 49, 36, 24] [163, 46, 44, 44, 40, 37, 35, 34, 25, 12, 9, 8, 4])," 13 (minimumBoxes [14, 12, 1, 27, 27, 29, 14, 12, 7, 6, 8, 42, 34, 42, 44, 46, 27, 49, 36, 24] [163, 46, 44, 44, 40, 37, 35, 34, 25, 12, 9, 8, 4]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimumBoxes [28, 3, 15, 44, 49, 25, 11, 50, 32, 2] [43, 39, 37, 36, 35, 35, 33, 32, 28, 25, 20, 16, 16, 6, 3, 2])," 8 (minimumBoxes [28, 3, 15, 44, 49, 25, 11, 50, 32, 2] [43, 39, 37, 36, 35, 35, 33, 32, 28, 25, 20, 16, 16, 6, 3, 2]))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minimumBoxes [38, 42, 47, 16, 36] [50, 49, 48, 47, 47, 47, 44, 44, 42, 38, 36, 35, 35, 34, 34, 33, 31, 29, 29, 26, 26, 23, 19, 19, 18, 15, 14, 14, 13, 12, 12, 11, 8, 7, 7, 5, 4, 1, 1])," 4 (minimumBoxes [38, 42, 47, 16, 36] [50, 49, 48, 47, 47, 47, 44, 44, 42, 38, 36, 35, 35, 34, 34, 33, 31, 29, 29, 26, 26, 23, 19, 19, 18, 15, 14, 14, 13, 12, 12, 11, 8, 7, 7, 5, 4, 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, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

apple_redistribution_into_boxes/java_tests/Main.java

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

apple_redistribution_into_boxes/meta.json

@@ -0,0 +1,482 @@
+{
+    "id": 3334,
+    "name": "apple_redistribution_into_boxes",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/apple-redistribution-into-boxes/",
+    "date": "2024-03-03 00:00:00",
+    "task_description": "You are given an array `apple` of size `n` and an array `capacity` of size `m`. There are `n` packs where the `ith` pack contains `apple[i]` apples. There are `m` boxes as well, and the `ith` box has a capacity of `capacity[i]` apples. Return _the **minimum** number of boxes you need to select to redistribute these _`n`_ packs of apples into boxes_. **Note** that, apples from the same pack can be distributed into different boxes. **Example 1:** ``` **Input:** apple = [1,3,2], capacity = [4,3,1,5,2] **Output:** 2 **Explanation:** We will use boxes with capacities 4 and 5. It is possible to distribute the apples as the total capacity is greater than or equal to the total number of apples. ``` **Example 2:** ``` **Input:** apple = [5,5,5], capacity = [2,4,2,7] **Output:** 4 **Explanation:** We will need to use all the boxes. ``` **Constraints:** `1 <= n == apple.length <= 50` `1 <= m == capacity.length <= 50` `1 <= apple[i], capacity[i] <= 50` The input is generated such that it's possible to redistribute packs of apples into boxes.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "apple = [1,3,2], capacity = [4,3,1,5,2]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "apple = [5,5,5], capacity = [2,4,2,7]",
+            "output": "4 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    12,
+                    39,
+                    47,
+                    10,
+                    21,
+                    26,
+                    7,
+                    50
+                ],
+                [
+                    49,
+                    43,
+                    35,
+                    30,
+                    29,
+                    28,
+                    24,
+                    7
+                ]
+            ],
+            "output": 6
+        },
+        {
+            "input": [
+                [
+                    35,
+                    48,
+                    40,
+                    16,
+                    43,
+                    36,
+                    41,
+                    4
+                ],
+                [
+                    46,
+                    45,
+                    45,
+                    44,
+                    43,
+                    40,
+                    38,
+                    38,
+                    36,
+                    34,
+                    34,
+                    33,
+                    30,
+                    29,
+                    28,
+                    26,
+                    25,
+                    24,
+                    22,
+                    22,
+                    19,
+                    18,
+                    17,
+                    7,
+                    2,
+                    2,
+                    2,
+                    1
+                ]
+            ],
+            "output": 6
+        },
+        {
+            "input": [
+                [
+                    18,
+                    45,
+                    11,
+                    47,
+                    26,
+                    2,
+                    39,
+                    48,
+                    43,
+                    16,
+                    4,
+                    17,
+                    48,
+                    44,
+                    2,
+                    21,
+                    41,
+                    40,
+                    17,
+                    29,
+                    35,
+                    23,
+                    45,
+                    30,
+                    31,
+                    34,
+                    39
+                ],
+                [
+                    205,
+                    50,
+                    45,
+                    45,
+                    45,
+                    42,
+                    39,
+                    37,
+                    35,
+                    35,
+                    31,
+                    27,
+                    26,
+                    24,
+                    24,
+                    21,
+                    21,
+                    15,
+                    14,
+                    8,
+                    6
+                ]
+            ],
+            "output": 21
+        },
+        {
+            "input": [
+                [
+                    46,
+                    5,
+                    6,
+                    15,
+                    47,
+                    20,
+                    16,
+                    19,
+                    42,
+                    44,
+                    44,
+                    28,
+                    28,
+                    19,
+                    16,
+                    26,
+                    47,
+                    12,
+                    39,
+                    40,
+                    25,
+                    25,
+                    48,
+                    3,
+                    17,
+                    6,
+                    21,
+                    22,
+                    20,
+                    2,
+                    50,
+                    50,
+                    26,
+                    26,
+                    41,
+                    5,
+                    9,
+                    31,
+                    19,
+                    40,
+                    26
+                ],
+                [
+                    719,
+                    50,
+                    49,
+                    41,
+                    31,
+                    28,
+                    28,
+                    23,
+                    22,
+                    20,
+                    15,
+                    11,
+                    11,
+                    10,
+                    8,
+                    5
+                ]
+            ],
+            "output": 16
+        },
+        {
+            "input": [
+                [
+                    14,
+                    12,
+                    1,
+                    27,
+                    27,
+                    29,
+                    14,
+                    12,
+                    7,
+                    6,
+                    8,
+                    42,
+                    34,
+                    42,
+                    44,
+                    46,
+                    27,
+                    49,
+                    36,
+                    24
+                ],
+                [
+                    163,
+                    46,
+                    44,
+                    44,
+                    40,
+                    37,
+                    35,
+                    34,
+                    25,
+                    12,
+                    9,
+                    8,
+                    4
+                ]
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                [
+                    28,
+                    3,
+                    15,
+                    44,
+                    49,
+                    25,
+                    11,
+                    50,
+                    32,
+                    2
+                ],
+                [
+                    43,
+                    39,
+                    37,
+                    36,
+                    35,
+                    35,
+                    33,
+                    32,
+                    28,
+                    25,
+                    20,
+                    16,
+                    16,
+                    6,
+                    3,
+                    2
+                ]
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                [
+                    38,
+                    42,
+                    47,
+                    16,
+                    36
+                ],
+                [
+                    50,
+                    49,
+                    48,
+                    47,
+                    47,
+                    47,
+                    44,
+                    44,
+                    42,
+                    38,
+                    36,
+                    35,
+                    35,
+                    34,
+                    34,
+                    33,
+                    31,
+                    29,
+                    29,
+                    26,
+                    26,
+                    23,
+                    19,
+                    19,
+                    18,
+                    15,
+                    14,
+                    14,
+                    13,
+                    12,
+                    12,
+                    11,
+                    8,
+                    7,
+                    7,
+                    5,
+                    4,
+                    1,
+                    1
+                ]
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                [
+                    44,
+                    26,
+                    43,
+                    38,
+                    50,
+                    35,
+                    36,
+                    44,
+                    25,
+                    39,
+                    16,
+                    14,
+                    26,
+                    12,
+                    3,
+                    45,
+                    21,
+                    1,
+                    4,
+                    8,
+                    35,
+                    2,
+                    33,
+                    30,
+                    9,
+                    26,
+                    20,
+                    16,
+                    14,
+                    24,
+                    43,
+                    7
+                ],
+                [
+                    271,
+                    46,
+                    42,
+                    40,
+                    40,
+                    40,
+                    39,
+                    38,
+                    36,
+                    34,
+                    28,
+                    28,
+                    27,
+                    23,
+                    19,
+                    13,
+                    11,
+                    8,
+                    6
+                ]
+            ],
+            "output": 19
+        },
+        {
+            "input": [
+                [
+                    49,
+                    46,
+                    14,
+                    38,
+                    24,
+                    32,
+                    16,
+                    36,
+                    22,
+                    19,
+                    48,
+                    17,
+                    43,
+                    15,
+                    9,
+                    3,
+                    18,
+                    42,
+                    4,
+                    49,
+                    12,
+                    20,
+                    16,
+                    22,
+                    11,
+                    28,
+                    36,
+                    1,
+                    7,
+                    18,
+                    49,
+                    17,
+                    3,
+                    4,
+                    36,
+                    7,
+                    37,
+                    18,
+                    7,
+                    41,
+                    18,
+                    13,
+                    5
+                ],
+                [
+                    919,
+                    30,
+                    16,
+                    5
+                ]
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                [
+                    41,
+                    30,
+                    18,
+                    6
+                ],
+                [
+                    41,
+                    34,
+                    20
+                ]
+            ],
+            "output": 3
+        }
+    ],
+    "haskell_template": "minimumBoxes :: [Int] -> [Int] -> Int\nminimumBoxes apple capacity ",
+    "ocaml_template": "let minimumBoxes (apple: int list) (capacity: int list) : int =  ",
+    "scala_template": "def minimumBoxes(apple: List[Int],capacity: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimumBoxes(int[] apple, int[] capacity) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumBoxes(self, apple, capacity):\n        \"\"\"\n        :type apple: List[int]\n        :type capacity: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

apple_redistribution_into_boxes/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (minimumBoxes [1;3;2] [4;3;1;5;2])
+
+let test2 _ = assert_equal 4 (minimumBoxes [5;5;5] [2;4;2;7])
+
+let test3 _ = assert_equal 6 (minimumBoxes [12; 39; 47; 10; 21; 26; 7; 50] [49; 43; 35; 30; 29; 28; 24; 7])
+
+let test4 _ = assert_equal 6 (minimumBoxes [35; 48; 40; 16; 43; 36; 41; 4] [46; 45; 45; 44; 43; 40; 38; 38; 36; 34; 34; 33; 30; 29; 28; 26; 25; 24; 22; 22; 19; 18; 17; 7; 2; 2; 2; 1])
+
+let test5 _ = assert_equal 21 (minimumBoxes [18; 45; 11; 47; 26; 2; 39; 48; 43; 16; 4; 17; 48; 44; 2; 21; 41; 40; 17; 29; 35; 23; 45; 30; 31; 34; 39] [205; 50; 45; 45; 45; 42; 39; 37; 35; 35; 31; 27; 26; 24; 24; 21; 21; 15; 14; 8; 6])
+
+let test6 _ = assert_equal 16 (minimumBoxes [46; 5; 6; 15; 47; 20; 16; 19; 42; 44; 44; 28; 28; 19; 16; 26; 47; 12; 39; 40; 25; 25; 48; 3; 17; 6; 21; 22; 20; 2; 50; 50; 26; 26; 41; 5; 9; 31; 19; 40; 26] [719; 50; 49; 41; 31; 28; 28; 23; 22; 20; 15; 11; 11; 10; 8; 5])
+
+let test7 _ = assert_equal 13 (minimumBoxes [14; 12; 1; 27; 27; 29; 14; 12; 7; 6; 8; 42; 34; 42; 44; 46; 27; 49; 36; 24] [163; 46; 44; 44; 40; 37; 35; 34; 25; 12; 9; 8; 4])
+
+let test8 _ = assert_equal 8 (minimumBoxes [28; 3; 15; 44; 49; 25; 11; 50; 32; 2] [43; 39; 37; 36; 35; 35; 33; 32; 28; 25; 20; 16; 16; 6; 3; 2])
+
+let test9 _ = assert_equal 4 (minimumBoxes [38; 42; 47; 16; 36] [50; 49; 48; 47; 47; 47; 44; 44; 42; 38; 36; 35; 35; 34; 34; 33; 31; 29; 29; 26; 26; 23; 19; 19; 18; 15; 14; 14; 13; 12; 12; 11; 8; 7; 7; 5; 4; 1; 1])
+
+let test10 _ = assert_equal 19 (minimumBoxes [44; 26; 43; 38; 50; 35; 36; 44; 25; 39; 16; 14; 26; 12; 3; 45; 21; 1; 4; 8; 35; 2; 33; 30; 9; 26; 20; 16; 14; 24; 43; 7] [271; 46; 42; 40; 40; 40; 39; 38; 36; 34; 28; 28; 27; 23; 19; 13; 11; 8; 6])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumBoxes" >::: [
+        
+  "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

apple_redistribution_into_boxes/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumBoxes(List(1,3,2),List(4,3,1,5,2)), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumBoxes(List(5,5,5),List(2,4,2,7)), 4)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumBoxes(List(12, 39, 47, 10, 21, 26, 7, 50),List(49, 43, 35, 30, 29, 28, 24, 7)), 6)
+  }
+
+  test("test4") {
+    assertEquals(Main.minimumBoxes(List(35, 48, 40, 16, 43, 36, 41, 4),List(46, 45, 45, 44, 43, 40, 38, 38, 36, 34, 34, 33, 30, 29, 28, 26, 25, 24, 22, 22, 19, 18, 17, 7, 2, 2, 2, 1)), 6)
+  }
+
+  test("test5") {
+    assertEquals(Main.minimumBoxes(List(18, 45, 11, 47, 26, 2, 39, 48, 43, 16, 4, 17, 48, 44, 2, 21, 41, 40, 17, 29, 35, 23, 45, 30, 31, 34, 39),List(205, 50, 45, 45, 45, 42, 39, 37, 35, 35, 31, 27, 26, 24, 24, 21, 21, 15, 14, 8, 6)), 21)
+  }
+
+  test("test6") {
+    assertEquals(Main.minimumBoxes(List(46, 5, 6, 15, 47, 20, 16, 19, 42, 44, 44, 28, 28, 19, 16, 26, 47, 12, 39, 40, 25, 25, 48, 3, 17, 6, 21, 22, 20, 2, 50, 50, 26, 26, 41, 5, 9, 31, 19, 40, 26),List(719, 50, 49, 41, 31, 28, 28, 23, 22, 20, 15, 11, 11, 10, 8, 5)), 16)
+  }
+
+  test("test7") {
+    assertEquals(Main.minimumBoxes(List(14, 12, 1, 27, 27, 29, 14, 12, 7, 6, 8, 42, 34, 42, 44, 46, 27, 49, 36, 24),List(163, 46, 44, 44, 40, 37, 35, 34, 25, 12, 9, 8, 4)), 13)
+  }
+
+  test("test8") {
+    assertEquals(Main.minimumBoxes(List(28, 3, 15, 44, 49, 25, 11, 50, 32, 2),List(43, 39, 37, 36, 35, 35, 33, 32, 28, 25, 20, 16, 16, 6, 3, 2)), 8)
+  }
+
+  test("test9") {
+    assertEquals(Main.minimumBoxes(List(38, 42, 47, 16, 36),List(50, 49, 48, 47, 47, 47, 44, 44, 42, 38, 36, 35, 35, 34, 34, 33, 31, 29, 29, 26, 26, 23, 19, 19, 18, 15, 14, 14, 13, 12, 12, 11, 8, 7, 7, 5, 4, 1, 1)), 4)
+  }
+
+  test("test10") {
+    assertEquals(Main.minimumBoxes(List(44, 26, 43, 38, 50, 35, 36, 44, 25, 39, 16, 14, 26, 12, 3, 45, 21, 1, 4, 8, 35, 2, 33, 30, 9, 26, 20, 16, 14, 24, 43, 7),List(271, 46, 42, 40, 40, 40, 39, 38, 36, 34, 28, 28, 27, 23, 19, 13, 11, 8, 6)), 19)
+  }
+
+}

apply_bitwise_operations_to_make_strings_equal/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(true, makeStringsEqual("1010", "0110"));
+}
+@Test
+public void test2() {
+    assertEquals(false, makeStringsEqual("11", "00"));
+}
+
+}

apply_discount_to_prices/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("50", discountPrices("there are $1 $2 and 5$ candies in the shop", 50));
+}
+@Test
+public void test2() {
+    assertEquals("100", discountPrices("1 2 $3 4 $5 $6 7 8$ $9 $10$", 100));
+}
+
+}

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

apply_operations_on_array_to_maximize_sum_of_squares/meta.json

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

apply_operations_to_an_array/haskell_tests/Main.hs

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

apply_operations_to_an_array/java_tests/Main.java

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

apply_operations_to_an_array/ocaml_tests/main.ml

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

apply_operations_to_an_array/scala_tests/MySuite.scala

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

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

apply_operations_to_make_all_array_elements_equal_to_zero/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(true, checkArray(new ArrayList<>(Arrays.asList(2,2,3,1,1,0)), 3));
+}
+@Test
+public void test2() {
+    assertEquals(false, checkArray(new ArrayList<>(Arrays.asList(1,3,1,1)), 2));
+}
+
+}

apply_operations_to_make_all_array_elements_equal_to_zero/ocaml_tests/main.ml

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

apply_operations_to_make_all_array_elements_equal_to_zero/scala_tests/MySuite.scala

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

apply_operations_to_make_string_empty/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("aabcbbca", lastNonEmptyString("aabcbbca"));
+}
+@Test
+public void test2() {
+    assertEquals("abcd", lastNonEmptyString("abcd"));
+}
+
+}

apply_operations_to_make_two_strings_equal/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 (minOperations \"1100011000 \"  \"0101001010 \" 2)," 4 (minOperations "1100011000" "0101001010" 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minOperations \"10110 \"  \"00011 \" 4)," (-1) (minOperations "10110" "00011" 4))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minOperations  \"1111111001101010111111101010001110001100101110111011100001001000001001010010010100100101000010010011110011101010100000001011101110011010110111111000101000000100001000000110000010001010111010010100000101010011101100 \"  \"0001000110101011011001100110111000101111010101011000011101000001110110010011100111010101110110001010010001101100000010100110101001101101101110001110100111010100101110100101000001001110101011100111001101111111001111 \" 25)," (-1) (minOperations "1111111001101010111111101010001110001100101110111011100001001000001001010010010100100101000010010011110011101010100000001011101110011010110111111000101000000100001000000110000010001010111010010100000101010011101100" "0001000110101011011001100110111000101111010101011000011101000001110110010011100111010101110110001010010001101100000010100110101001101101101110001110100111010100101110100101000001001110101011100111001101111111001111" 25))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minOperations  \"110 \"  \"010 \" 421)," (-1) (minOperations "110" "010" 421))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minOperations  \"01101000000000011111100010000111110100010010100110101100101101111111110110110101111011101110101110111111111010101001101001000100001010001010111100011101100011011010010011000000101100001000111000111010000100010110010110010011011101110011110110110100111110011100000001011110111111011110001001001110010010011101100010101000001100001000011111101110101110101011110101111011110111010000110100101110001000010110000110110011110100101111000011111010001101 \"  \"10000110001010101010111101110110101011111110010001001111111111011111001011001010011000001010101100010100011110011111010100011000101110101111011000100011110111101111000011001101101100001111100110001110011010111101001101101110011011001101010101010110101010001100011111101011111001111101011100111100111001100001000001100100100000110001101100100000111111100100000001010001110101001111000001110000111010111000111010011011011000001111101100011110011000 \" 282)," (-1) (minOperations "01101000000000011111100010000111110100010010100110101100101101111111110110110101111011101110101110111111111010101001101001000100001010001010111100011101100011011010010011000000101100001000111000111010000100010110010110010011011101110011110110110100111110011100000001011110111111011110001001001110010010011101100010101000001100001000011111101110101110101011110101111011110111010000110100101110001000010110000110110011110100101111000011111010001101" "10000110001010101010111101110110101011111110010001001111111111011111001011001010011000001010101100010100011110011111010100011000101110101111011000100011110111101111000011001101101100001111100110001110011010111101001101101110011011001101010101010110101010001100011111101011111001111101011100111100111001100001000001100100100000110001101100100000111111100100000001010001110101001111000001110000111010111000111010011011011000001111101100011110011000" 282))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minOperations  \"1101001000101001101100000100111111000100011001011111100010100010011101011111000001000011101010010110110000111000000010111101110000100101011101000010001101100000000000010011100100001100100111101001010100000001110100011100010010110100111110010010110001101111110011001101100011000101111010111101101101101001100110110110100011110000100010101110101001011001011111110011101000111111011110101000110010101001001011100001001000011010110001001 \"  \"1001101110111100010000000110100011011011000010110101011111010011111001111000101000001100010001111110010000001101101100000101110111001101010010111100010111000111110001101001010001011100101001010010101000111111000100000011101010111111111000010010101010001011101111110111110001011001111011011000001010011101110001001001100001111011110011010000011011101000010000010000100000101111101010101110011101111101101100111101010001001000010010000 \" 327)," (-1) (minOperations "1101001000101001101100000100111111000100011001011111100010100010011101011111000001000011101010010110110000111000000010111101110000100101011101000010001101100000000000010011100100001100100111101001010100000001110100011100010010110100111110010010110001101111110011001101100011000101111010111101101101101001100110110110100011110000100010101110101001011001011111110011101000111111011110101000110010101001001011100001001000011010110001001" "1001101110111100010000000110100011011011000010110101011111010011111001111000101000001100010001111110010000001101101100000101110111001101010010111100010111000111110001101001010001011100101001010010101000111111000100000011101010111111111000010010101010001011101111110111110001011001111011011000001010011101110001001001100001111011110011010000011011101000010000010000100000101111101010101110011101111101101100111101010001001000010010000" 327))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minOperations  \"01110110111110101110000110101011010110010010111101101001011101110001110101010111010110000101110100101100001100010111111011110100011010100101010110111010011110001000 \"  \"10011100110101000110011101000111000110001111011000100011110001111001110000101011101000011011001001111000010111101111001011111111101100001110000111001011111101010001 \" 336)," 84 (minOperations "01110110111110101110000110101011010110010010111101101001011101110001110101010111010110000101110100101100001100010111111011110100011010100101010110111010011110001000" "10011100110101000110011101000111000110001111011000100011110001111001110000101011101000011011001001111000010111101111001011111111101100001110000111001011111101010001" 336))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minOperations  \"010110000101011010111001010100100010100001110101111111011101001101010011001101100111011000000100101010001010100100110110101000111010001011010001001101000011100001110011011110011001111011010100110000011101101001010011011010110101011011101011100001100011010111100011101011001001100111101011 \"  \"110101010101001001011000111111111101101000110001001101111110010001100100100111101001010000001001110011111001100111011101011111111101101001110101111001111111010010100111110101100100101100010000011101000010110000010111011110001100000110110100111110011111010101101110111010001110110110101011 \" 410)," 141 (minOperations "010110000101011010111001010100100010100001110101111111011101001101010011001101100111011000000100101010001010100100110110101000111010001011010001001101000011100001110011011110011001111011010100110000011101101001010011011010110101011011101011100001100011010111100011101011001001100111101011" "110101010101001001011000111111111101101000110001001101111110010001100100100111101001010000001001110011111001100111011101011111111101101001110101111001111111010010100111110101100100101100010000011101000010110000010111011110001100000110110100111110011111010101101110111010001110110110101011" 410))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minOperations  \"11001001000110011111100001001110111101110011101001110110001011000001010000100011110111001001010100011101000000111111000011110000011001010010111000011100010001111010001000101100100111000001011110010101010010100000011111111110010001101011000111000011010000000110011101010101001000010101100011110010000010111000111011001100100101100110111011000100000010000110100010001011111000011011010001000001110100111001011010010110101101000000000 \"  \"10011000100001001110001111101110100001000111000000101010100000110101110001000011010010111111001001111100010000011011101111001001110000010111111100111000100111000110100111100011110110001101101010100101001011000000100010000000011000100011110111110110010100111000101010000001100001111100010101101111111110110001110001101010100011100111010101110101101011000111011010001110111011110010101011000111101101101101111000100110010110110110001 \" 408)," (-1) (minOperations "11001001000110011111100001001110111101110011101001110110001011000001010000100011110111001001010100011101000000111111000011110000011001010010111000011100010001111010001000101100100111000001011110010101010010100000011111111110010001101011000111000011010000000110011101010101001000010101100011110010000010111000111011001100100101100110111011000100000010000110100010001011111000011011010001000001110100111001011010010110101101000000000" "10011000100001001110001111101110100001000111000000101010100000110101110001000011010010111111001001111100010000011011101111001001110000010111111100111000100111000110100111100011110110001101101010100101001011000000100010000000011000100011110111110110010100111000101010000001100001111100010101101111111110110001110001101010100011100111010101110101101011000111011010001110111011110010101011000111101101101101111000100110010110110110001" 408))
+
+
+-- 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

apply_operations_to_make_two_strings_equal/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(4, minOperations("1100011000", "0101001010", 2));
+}
+@Test
+public void test2() {
+    assertEquals(-1, minOperations("10110", "00011", 4));
+}
+
+}

apply_operations_to_make_two_strings_equal/meta.json

@@ -0,0 +1,107 @@
+{
+    "id": 3033,
+    "name": "apply_operations_to_make_two_strings_equal",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/apply-operations-to-make-two-strings-equal/",
+    "date": "2023-10-01 00:00:00",
+    "task_description": "You are given two **0-indexed** binary strings `s1` and `s2`, both of length `n`, and a positive integer `x`. You can perform any of the following operations on the string `s1` **any** number of times: Choose two indices `i` and `j`, and flip both `s1[i]` and `s1[j]`. The cost of this operation is `x`. Choose an index `i` such that `i < n - 1` and flip both `s1[i]` and `s1[i + 1]`. The cost of this operation is `1`. Return _the **minimum** cost needed to make the strings _`s1`_ and _`s2`_ equal, or return _`-1`_ if it is impossible._ **Note** that flipping a character means changing it from `0` to `1` or vice-versa. **Example 1:** ``` **Input:** s1 = \"1100011000\", s2 = \"0101001010\", x = 2 **Output:** 4 **Explanation:** We can do the following operations: - Choose i = 3 and apply the second operation. The resulting string is s1 = \"110**11**11000\". - Choose i = 4 and apply the second operation. The resulting string is s1 = \"1101**00**1000\". - Choose i = 0 and j = 8 and apply the first operation. The resulting string is s1 = \"**0**1010010**1**0\" = s2. The total cost is 1 + 1 + 2 = 4. It can be shown that it is the minimum cost possible. ``` **Example 2:** ``` **Input:** s1 = \"10110\", s2 = \"00011\", x = 4 **Output:** -1 **Explanation:** It is not possible to make the two strings equal. ``` **Constraints:** `n == s1.length == s2.length` `1 <= n, x <= 500` `s1` and `s2` consist only of the characters `'0'` and `'1'`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s1 = \"1100011000\", s2 = \"0101001010\", x = 2",
+            "output": "4 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s1 = \"10110\", s2 = \"00011\", x = 4",
+            "output": "-1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"1111111001101010111111101010001110001100101110111011100001001000001001010010010100100101000010010011110011101010100000001011101110011010110111111000101000000100001000000110000010001010111010010100000101010011101100\"",
+                "\"0001000110101011011001100110111000101111010101011000011101000001110110010011100111010101110110001010010001101100000010100110101001101101101110001110100111010100101110100101000001001110101011100111001101111111001111\"",
+                25
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                "\"110\"",
+                "\"010\"",
+                421
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                "\"01101000000000011111100010000111110100010010100110101100101101111111110110110101111011101110101110111111111010101001101001000100001010001010111100011101100011011010010011000000101100001000111000111010000100010110010110010011011101110011110110110100111110011100000001011110111111011110001001001110010010011101100010101000001100001000011111101110101110101011110101111011110111010000110100101110001000010110000110110011110100101111000011111010001101\"",
+                "\"10000110001010101010111101110110101011111110010001001111111111011111001011001010011000001010101100010100011110011111010100011000101110101111011000100011110111101111000011001101101100001111100110001110011010111101001101101110011011001101010101010110101010001100011111101011111001111101011100111100111001100001000001100100100000110001101100100000111111100100000001010001110101001111000001110000111010111000111010011011011000001111101100011110011000\"",
+                282
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                "\"1101001000101001101100000100111111000100011001011111100010100010011101011111000001000011101010010110110000111000000010111101110000100101011101000010001101100000000000010011100100001100100111101001010100000001110100011100010010110100111110010010110001101111110011001101100011000101111010111101101101101001100110110110100011110000100010101110101001011001011111110011101000111111011110101000110010101001001011100001001000011010110001001\"",
+                "\"1001101110111100010000000110100011011011000010110101011111010011111001111000101000001100010001111110010000001101101100000101110111001101010010111100010111000111110001101001010001011100101001010010101000111111000100000011101010111111111000010010101010001011101111110111110001011001111011011000001010011101110001001001100001111011110011010000011011101000010000010000100000101111101010101110011101111101101100111101010001001000010010000\"",
+                327
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                "\"01110110111110101110000110101011010110010010111101101001011101110001110101010111010110000101110100101100001100010111111011110100011010100101010110111010011110001000\"",
+                "\"10011100110101000110011101000111000110001111011000100011110001111001110000101011101000011011001001111000010111101111001011111111101100001110000111001011111101010001\"",
+                336
+            ],
+            "output": 84
+        },
+        {
+            "input": [
+                "\"010110000101011010111001010100100010100001110101111111011101001101010011001101100111011000000100101010001010100100110110101000111010001011010001001101000011100001110011011110011001111011010100110000011101101001010011011010110101011011101011100001100011010111100011101011001001100111101011\"",
+                "\"110101010101001001011000111111111101101000110001001101111110010001100100100111101001010000001001110011111001100111011101011111111101101001110101111001111111010010100111110101100100101100010000011101000010110000010111011110001100000110110100111110011111010101101110111010001110110110101011\"",
+                410
+            ],
+            "output": 141
+        },
+        {
+            "input": [
+                "\"11001001000110011111100001001110111101110011101001110110001011000001010000100011110111001001010100011101000000111111000011110000011001010010111000011100010001111010001000101100100111000001011110010101010010100000011111111110010001101011000111000011010000000110011101010101001000010101100011110010000010111000111011001100100101100110111011000100000010000110100010001011111000011011010001000001110100111001011010010110101101000000000\"",
+                "\"10011000100001001110001111101110100001000111000000101010100000110101110001000011010010111111001001111100010000011011101111001001110000010111111100111000100111000110100111100011110110001101101010100101001011000000100010000000011000100011110111110110010100111000101010000001100001111100010101101111111110110001110001101010100011100111010101110101101011000111011010001110111011110010101011000111101101101101111000100110010110110110001\"",
+                408
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                "\"0000100011100101101101100\"",
+                "\"1110111100001010010111111\"",
+                94
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                "01001110110111001110111100001111110101101111000111111000101101111111100100010001010001011100011101101110000100101001111011011000011000110000000000001000000001010001100001100011000111110100100111000000111101010000001100110110011011000110100101",
+                "00011011000011000100010111010101110000101001000011110111010000111001010101001110010010110110100001010000010011111010000011000110111111101101011011111010110010111000011010000111101100010101101010001111100110001100001010111011001010001000111100",
+                422
+            ],
+            "output": 120
+        },
+        {
+            "input": [
+                "010101011110111010000010100100100000100001010011110101001000011101011010000001100010001001110110110011101001001111111011111010101001110100001110011010100011011101000000010000010000110",
+                "001111101001000100111000011100101011101100000010010010111000111001101111110011011111000111000111100000000010011000010010000101110110010110100000000011001011111011000010010000001111010",
+                1
+            ],
+            "output": 50
+        }
+    ],
+    "haskell_template": "minOperations :: String -> String -> Int -> Int\nminOperations s1 s2 x ",
+    "ocaml_template": "let minOperations (s1: string) (s2: string) (x: int) : int =  ",
+    "scala_template": "def minOperations(s1: String,s2: String,x: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minOperations(String s1, String s2, int x) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minOperations(self, s1, s2, x):\n        \"\"\"\n        :type s1: str\n        :type s2: str\n        :type x: int\n        :rtype: int\n        \"\"\"\n        "
+}

apply_operations_to_make_two_strings_equal/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 4 (minOperations "1100011000" "0101001010" 2)
+
+let test2 _ = assert_equal (-1) (minOperations "10110" "00011" 4)
+
+let test3 _ = assert_equal (-1) (minOperations "1111111001101010111111101010001110001100101110111011100001001000001001010010010100100101000010010011110011101010100000001011101110011010110111111000101000000100001000000110000010001010111010010100000101010011101100" "0001000110101011011001100110111000101111010101011000011101000001110110010011100111010101110110001010010001101100000010100110101001101101101110001110100111010100101110100101000001001110101011100111001101111111001111" 25)
+
+let test4 _ = assert_equal (-1) (minOperations "110" "010" 421)
+
+let test5 _ = assert_equal (-1) (minOperations "01101000000000011111100010000111110100010010100110101100101101111111110110110101111011101110101110111111111010101001101001000100001010001010111100011101100011011010010011000000101100001000111000111010000100010110010110010011011101110011110110110100111110011100000001011110111111011110001001001110010010011101100010101000001100001000011111101110101110101011110101111011110111010000110100101110001000010110000110110011110100101111000011111010001101" "10000110001010101010111101110110101011111110010001001111111111011111001011001010011000001010101100010100011110011111010100011000101110101111011000100011110111101111000011001101101100001111100110001110011010111101001101101110011011001101010101010110101010001100011111101011111001111101011100111100111001100001000001100100100000110001101100100000111111100100000001010001110101001111000001110000111010111000111010011011011000001111101100011110011000" 282)
+
+let test6 _ = assert_equal (-1) (minOperations "1101001000101001101100000100111111000100011001011111100010100010011101011111000001000011101010010110110000111000000010111101110000100101011101000010001101100000000000010011100100001100100111101001010100000001110100011100010010110100111110010010110001101111110011001101100011000101111010111101101101101001100110110110100011110000100010101110101001011001011111110011101000111111011110101000110010101001001011100001001000011010110001001" "1001101110111100010000000110100011011011000010110101011111010011111001111000101000001100010001111110010000001101101100000101110111001101010010111100010111000111110001101001010001011100101001010010101000111111000100000011101010111111111000010010101010001011101111110111110001011001111011011000001010011101110001001001100001111011110011010000011011101000010000010000100000101111101010101110011101111101101100111101010001001000010010000" 327)
+
+let test7 _ = assert_equal 84 (minOperations "01110110111110101110000110101011010110010010111101101001011101110001110101010111010110000101110100101100001100010111111011110100011010100101010110111010011110001000" "10011100110101000110011101000111000110001111011000100011110001111001110000101011101000011011001001111000010111101111001011111111101100001110000111001011111101010001" 336)
+
+let test8 _ = assert_equal 141 (minOperations "010110000101011010111001010100100010100001110101111111011101001101010011001101100111011000000100101010001010100100110110101000111010001011010001001101000011100001110011011110011001111011010100110000011101101001010011011010110101011011101011100001100011010111100011101011001001100111101011" "110101010101001001011000111111111101101000110001001101111110010001100100100111101001010000001001110011111001100111011101011111111101101001110101111001111111010010100111110101100100101100010000011101000010110000010111011110001100000110110100111110011111010101101110111010001110110110101011" 410)
+
+let test9 _ = assert_equal (-1) (minOperations "11001001000110011111100001001110111101110011101001110110001011000001010000100011110111001001010100011101000000111111000011110000011001010010111000011100010001111010001000101100100111000001011110010101010010100000011111111110010001101011000111000011010000000110011101010101001000010101100011110010000010111000111011001100100101100110111011000100000010000110100010001011111000011011010001000001110100111001011010010110101101000000000" "10011000100001001110001111101110100001000111000000101010100000110101110001000011010010111111001001111100010000011011101111001001110000010111111100111000100111000110100111100011110110001101101010100101001011000000100010000000011000100011110111110110010100111000101010000001100001111100010101101111111110110001110001101010100011100111010101110101101011000111011010001110111011110010101011000111101101101101111000100110010110110110001" 408)
+
+let test10 _ = assert_equal (-1) (minOperations "0000100011100101101101100" "1110111100001010010111111" 94)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minOperations" >::: [
+        
+  "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

apply_operations_to_make_two_strings_equal/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minOperations("1100011000","0101001010",2), 4)
+  }
+
+  test("test2") {
+    assertEquals(Main.minOperations("10110","00011",4), -1)
+  }
+
+  test("test3") {
+    assertEquals(Main.minOperations("1111111001101010111111101010001110001100101110111011100001001000001001010010010100100101000010010011110011101010100000001011101110011010110111111000101000000100001000000110000010001010111010010100000101010011101100","0001000110101011011001100110111000101111010101011000011101000001110110010011100111010101110110001010010001101100000010100110101001101101101110001110100111010100101110100101000001001110101011100111001101111111001111",25), -1)
+  }
+
+  test("test4") {
+    assertEquals(Main.minOperations("110","010",421), -1)
+  }
+
+  test("test5") {
+    assertEquals(Main.minOperations("01101000000000011111100010000111110100010010100110101100101101111111110110110101111011101110101110111111111010101001101001000100001010001010111100011101100011011010010011000000101100001000111000111010000100010110010110010011011101110011110110110100111110011100000001011110111111011110001001001110010010011101100010101000001100001000011111101110101110101011110101111011110111010000110100101110001000010110000110110011110100101111000011111010001101","10000110001010101010111101110110101011111110010001001111111111011111001011001010011000001010101100010100011110011111010100011000101110101111011000100011110111101111000011001101101100001111100110001110011010111101001101101110011011001101010101010110101010001100011111101011111001111101011100111100111001100001000001100100100000110001101100100000111111100100000001010001110101001111000001110000111010111000111010011011011000001111101100011110011000",282), -1)
+  }
+
+  test("test6") {
+    assertEquals(Main.minOperations("1101001000101001101100000100111111000100011001011111100010100010011101011111000001000011101010010110110000111000000010111101110000100101011101000010001101100000000000010011100100001100100111101001010100000001110100011100010010110100111110010010110001101111110011001101100011000101111010111101101101101001100110110110100011110000100010101110101001011001011111110011101000111111011110101000110010101001001011100001001000011010110001001","1001101110111100010000000110100011011011000010110101011111010011111001111000101000001100010001111110010000001101101100000101110111001101010010111100010111000111110001101001010001011100101001010010101000111111000100000011101010111111111000010010101010001011101111110111110001011001111011011000001010011101110001001001100001111011110011010000011011101000010000010000100000101111101010101110011101111101101100111101010001001000010010000",327), -1)
+  }
+
+  test("test7") {
+    assertEquals(Main.minOperations("01110110111110101110000110101011010110010010111101101001011101110001110101010111010110000101110100101100001100010111111011110100011010100101010110111010011110001000","10011100110101000110011101000111000110001111011000100011110001111001110000101011101000011011001001111000010111101111001011111111101100001110000111001011111101010001",336), 84)
+  }
+
+  test("test8") {
+    assertEquals(Main.minOperations("010110000101011010111001010100100010100001110101111111011101001101010011001101100111011000000100101010001010100100110110101000111010001011010001001101000011100001110011011110011001111011010100110000011101101001010011011010110101011011101011100001100011010111100011101011001001100111101011","110101010101001001011000111111111101101000110001001101111110010001100100100111101001010000001001110011111001100111011101011111111101101001110101111001111111010010100111110101100100101100010000011101000010110000010111011110001100000110110100111110011111010101101110111010001110110110101011",410), 141)
+  }
+
+  test("test9") {
+    assertEquals(Main.minOperations("11001001000110011111100001001110111101110011101001110110001011000001010000100011110111001001010100011101000000111111000011110000011001010010111000011100010001111010001000101100100111000001011110010101010010100000011111111110010001101011000111000011010000000110011101010101001000010101100011110010000010111000111011001100100101100110111011000100000010000110100010001011111000011011010001000001110100111001011010010110101101000000000","10011000100001001110001111101110100001000111000000101010100000110101110001000011010010111111001001111100010000011011101111001001110000010111111100111000100111000110100111100011110110001101101010100101001011000000100010000000011000100011110111110110010100111000101010000001100001111100010101101111111110110001110001101010100011100111010101110101101011000111011010001110111011110010101011000111101101101101111000100110010110110110001",408), -1)
+  }
+
+  test("test10") {
+    assertEquals(Main.minOperations("0000100011100101101101100","1110111100001010010111111",94), -1)
+  }
+
+}

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