6b09971df99a3b60672b21b6294001be8734c1264de3a1c37cb0dffe06141536

.gitattributes

@@ -208,3 +208,6 @@ meta2/.DS_Store filter=lfs diff=lfs merge=lfs -text
 meta2/add_edges_to_make_degrees_of_all_nodes_even/meta.json filter=lfs diff=lfs merge=lfs -text
 meta2/all_divisions_with_the_highest_score_of_a_binary_array/meta.json filter=lfs diff=lfs merge=lfs -text
 mice_and_cheese/meta.json filter=lfs diff=lfs merge=lfs -text
+minimize_maximum_of_array/meta.json filter=lfs diff=lfs merge=lfs -text
+minimize_or_of_remaining_elements_using_operations/meta.json filter=lfs diff=lfs merge=lfs -text
+minimize_the_maximum_difference_of_pairs/meta.json filter=lfs diff=lfs merge=lfs -text

min_max_game/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minMaxGame(List(1,3,5,2,4,8,2,2)), 1)
+  }
+
+  test("test2") {
+    assertEquals(Main.minMaxGame(List(3)), 3)
+  }
+
+  test("test3") {
+    assertEquals(Main.minMaxGame(115040532,691122985,74905644,691122985,74905644,488737920,409049507,691122985,74905644,424016316,139550887,488737920,409049507,778486804,581936863,691122985,74905644,898320970,424016316,316332152,322747948,139550887,10127500,488737920,409049507,714000633,529661213,778486804,581936863,766268468,256616097,691122985,893168349,74905644,898320970,562091841,623374598,424016316,316332152,175024652,322747948,421471664,139550887,27323869,10127500,285386703,54510532,488737920,920450369,409049507,714000633,376483632,529661213,689244382,749711836,778486804,581936863,952610726,46933645,766268468,256616097,930245976,109029077,691122985), 115040532)
+  }
+
+  test("test4") {
+    assertEquals(Main.minMaxGame(422752264,444626536,383451709,444626536,964694290,383451709,444626536,354937044), 422752264)
+  }
+
+  test("test5") {
+    assertEquals(Main.minMaxGame(347432181,347432181,347432181,253225415), 347432181)
+  }
+
+  test("test6") {
+    assertEquals(Main.minMaxGame(277872296,945927896,351536846,945927896,351536846,505308252,355276338,945927896,351536846,740924939,38550376,505308252,355276338,720623023,50265300,945927896,351536846,818710986,268024035,740924939,38550376,917469833,218828997,505308252,355276338,675186659,272427923,720623023,50265300,349134637,197930247,945927896,351536846,933128750,89429569,818710986,268024035,630711263,740924939,442693871,38550376,987228952,110075355,917469833,218828997,825822362,168084080,505308252,355276338,930388442,188207825,675186659,272427923,816044008,613681487,720623023,50265300,918806830,349134637,278273618,197930247,846327293,114080947,945927896,351536846,962339954,153247899,933128750,89429569,949890359,736501846,818710986,268024035,936649815,630711263,623451241,740924939,784006358,364968461,442693871,38550376,827637389,775002894,987228952,110075355,898363618,496412781,917469833,218828997,775423695,299108265,825822362,168084080,655056704,55736741,505308252,355276338,822549513,165382074,930388442,188207825,623202735,97039735,675186659,272427923,899139750,58820112,816044008,613681487,692107265,446140510,720623023,50265300,786653476,631607382,918806830,738179041,349134637,3081800,278273618,197930247,814391196,846327293,839751160,114080947,766307757,394016082,945927896,842046573,351536846,581539229,962339954,153247899,893052643,933128750,886264387,237453609,89429569,168548190,949890359,736501846,874536926,390388306,818710986,268024035,930890158,936649815,787292160,630711263,790680442,623451241,528577751,757668896,740924939,540340338,784006358,364968461,634924643,442693871,402084206,38550376,50388559,486527953,827637389,889740846,775002894,987228952,711758512,110075355,554558129,898363618,430338156,855273022,496412781,917469833,513275787,287567580,218828997,775423695,544183099,960564854,299108265,403334797,825822362,168084080,420433761,257316455,655056704,614047974,55736741,55437983,505308252,355276338,829117431,425539800,822549513,473149306,165382074,930388442,219356010,188207825,221601673,339915824,623202735,97039735,643265311,675186659,302235312,801212847,272427923,899139750,473530827,701114055,58820112,103017505,816044008,613681487,819740209,623887143,692107265,446140510,818007276,45103587,720623023,50265300,236708934,646052908,786653476,631607382,943759801,918806830,256451102,738179041,798967010,56615261,349134637,3081800,585996046,278273618,187195679,365793711,197930247,814391196,1711047,846327293,989073716,454322636,839751160,803562099,114080947,656466739,766307757,829671791,394016082,945927896,556552137), 277872296)
+  }
+
+  test("test7") {
+    assertEquals(Main.minMaxGame(439363306,983086361,18639521,983086361,18639521,926360015,429073836,983086361,18639521,618347797,331389171,926360015,429073836,823614485,206463919,983086361,18639521,551614501,528697263,618347797,729566617,331389171,806609119,926360015,429073836,906955449,28743328,823614485,575701114,206463919,430845510,983086361,18639521,476762353,551614501,483033277,528697263,757187572,618347797,289394534,930884662,729566617,331389171,248606565,828364048,806609119,104101301,926360015,586131558,429073836,124381100,906955449,871344524,28743328,372630435,823614485,575701114,898787203,206463919,11428664,430845510,479380797,101634865,983086361), 439363306)
+  }
+
+}

minimize_length_of_array_using_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(1, minimumArrayLength(Arrays.asList(1,4,3,1)));
+}
+@Test
+public void test2() {
+    assertEquals(2, minimumArrayLength(Arrays.asList(5,5,5,10,5)));
+}
+@Test
+public void test3() {
+    assertEquals(1, minimumArrayLength(Arrays.asList(2,3,4)));
+}
+
+}

minimize_manhattan_distances/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(12, minimumDistance(Arrays.asList(Arrays.asList(3,10),Arrays.asList(5,15),Arrays.asList(10,2),Arrays.asList(4,4))));
+}
+@Test
+public void test2() {
+    assertEquals(0, minimumDistance(Arrays.asList(Arrays.asList(1,1),Arrays.asList(1,1),Arrays.asList(1,1))));
+}
+
+}

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

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

minimize_maximum_of_array/meta.json

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

minimize_maximum_of_array/ocaml_tests/main.ml

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

minimize_maximum_of_array/scala_tests/MySuite.scala

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

minimize_or_of_remaining_elements_using_operations/java_tests/Main.java

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

minimize_or_of_remaining_elements_using_operations/meta.json

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

minimize_result_by_adding_parentheses_to_expression/haskell_tests/Main.hs

@@ -0,0 +1,27 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minimizeResult \"247+38 \")," "2(47+38)" (minimizeResult "247+38"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimizeResult \"12+34 \")," "1(2+3)4" (minimizeResult "12+34"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimizeResult \"999+999 \")," "(999+999)" (minimizeResult "999+999"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimize_result_by_adding_parentheses_to_expression/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals("247+38", minimizeResult("247+38"));
+}
+@Test
+public void test2() {
+    assertEquals("12+34", minimizeResult("12+34"));
+}
+@Test
+public void test3() {
+    assertEquals("999+999", minimizeResult("999+999"));
+}
+
+}

minimize_result_by_adding_parentheses_to_expression/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 2328,
+    "name": "minimize_result_by_adding_parentheses_to_expression",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimize-result-by-adding-parentheses-to-expression/",
+    "date": "1648944000000",
+    "task_description": "You are given a **0-indexed** string `expression` of the form `\"<num1>+<num2>\"` where `<num1>` and `<num2>` represent positive integers. Add a pair of parentheses to `expression` such that after the addition of parentheses, `expression` is a **valid** mathematical expression and evaluates to the **smallest** possible value. The left parenthesis **must** be added to the left of `'+'` and the right parenthesis **must** be added to the right of `'+'`. Return `expression`_ after adding a pair of parentheses such that _`expression`_ evaluates to the **smallest** possible value._ If there are multiple answers that yield the same result, return any of them. The input has been generated such that the original value of `expression`, and the value of `expression` after adding any pair of parentheses that meets the requirements fits within a signed 32-bit integer. **Example 1:** ``` **Input:** expression = \"247+38\" **Output:** \"2(47+38)\" **Explanation:** The `expression` evaluates to 2 * (47 + 38) = 2 * 85 = 170. Note that \"2(4)7+38\" is invalid because the right parenthesis must be to the right of the `'+'`. It can be shown that 170 is the smallest possible value. ``` **Example 2:** ``` **Input:** expression = \"12+34\" **Output:** \"1(2+3)4\" **Explanation:** The expression evaluates to 1 * (2 + 3) * 4 = 1 * 5 * 4 = 20. ``` **Example 3:** ``` **Input:** expression = \"999+999\" **Output:** \"(999+999)\" **Explanation:** The `expression` evaluates to 999 + 999 = 1998. ``` **Constraints:** `3 <= expression.length <= 10` `expression` consists of digits from `'1'` to `'9'` and `'+'`. `expression` starts and ends with digits. `expression` contains exactly one `'+'`. The original value of `expression`, and the value of `expression` after adding any pair of parentheses that meets the requirements fits within a signed 32-bit integer.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "expression = \"247+38\"",
+            "output": "\"2(47+38)\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "expression = \"12+34\"",
+            "output": "\"1(2+3)4\" "
+        },
+        {
+            "label": "Example 3",
+            "input": "expression = \"999+999\"",
+            "output": "\"(999+999)\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "69+1",
+            "output": "6(9+1)"
+        },
+        {
+            "input": "5+57888",
+            "output": "(5+5788)8"
+        },
+        {
+            "input": "2281+9868",
+            "output": "(2281+9868)"
+        },
+        {
+            "input": "718+2",
+            "output": "7(18+2)"
+        },
+        {
+            "input": "9+1776",
+            "output": "(9+177)6"
+        },
+        {
+            "input": "75+59239",
+            "output": "(75+592)39"
+        },
+        {
+            "input": "2+925",
+            "output": "(2+9)25"
+        },
+        {
+            "input": "3347+15",
+            "output": "3(347+15)"
+        },
+        {
+            "input": "89337+98",
+            "output": "89(337+98)"
+        },
+        {
+            "input": "376+635",
+            "output": "(376+635)"
+        }
+    ],
+    "haskell_template": "minimizeResult :: String -> String\nminimizeResult expression ",
+    "ocaml_template": "let minimizeResult (expression: string) : string =  ",
+    "scala_template": "def minimizeResult(expression: String): String = { \n    \n}",
+    "java_template": "public static String minimizeResult(String expression) {\n\n}",
+    "python_template": "class Solution(object):\n    def minimizeResult(self, expression):\n        \"\"\"\n        :type expression: str\n        :rtype: str\n        \"\"\"\n        "
+}

minimize_result_by_adding_parentheses_to_expression/ocaml_tests/main.ml

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

minimize_result_by_adding_parentheses_to_expression/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimizeResult("247+38"), "2(47+38)")
+  }
+
+  test("test2") {
+    assertEquals(Main.minimizeResult("12+34"), "1(2+3)4")
+  }
+
+  test("test3") {
+    assertEquals(Main.minimizeResult("999+999"), "(999+999)")
+  }
+
+}

minimize_string_length/haskell_tests/Main.hs

@@ -0,0 +1,47 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+minimizedStringLength :: String -> Int
+minimizedStringLength s = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minimizedStringLength \"aaabc \")," 3 (minimizedStringLength "aaabc"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimizedStringLength \"cbbd \")," 3 (minimizedStringLength "cbbd"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimizedStringLength \"baadccab \")," 4 (minimizedStringLength "baadccab"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimizedStringLength  \"tcvpsshshoempgosrmzprwdcqyjxtubmrctsxiplwhdnvnzl \")," 23 (minimizedStringLength "tcvpsshshoempgosrmzprwdcqyjxtubmrctsxiplwhdnvnzl"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimizedStringLength  \"zbdiihopkvppoyujbpqwlazodrulomflmeektpolhnlinorgkoabhesiufhjxyouoayxffbs \")," 25 (minimizedStringLength "zbdiihopkvppoyujbpqwlazodrulomflmeektpolhnlinorgkoabhesiufhjxyouoayxffbs"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimizedStringLength  \"bfregovatvtfocylmcrvldljokensrvtuasjblfrppljuafmpanfvdvjmhijjzrevithz \")," 23 (minimizedStringLength "bfregovatvtfocylmcrvldljokensrvtuasjblfrppljuafmpanfvdvjmhijjzrevithz"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimizedStringLength  \"daokppkqwypwzrcyoxpqayzqabuxbgafmehmrmcqpowltebbzcqkgxndvblvnrxatq \")," 23 (minimizedStringLength "daokppkqwypwzrcyoxpqayzqabuxbgafmehmrmcqpowltebbzcqkgxndvblvnrxatq"))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimizedStringLength  \"wqrl \")," 4 (minimizedStringLength "wqrl"))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minimizedStringLength  \"bprwvtx \")," 7 (minimizedStringLength "bprwvtx"))
+
+
+-- 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

minimize_string_length/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, minimizedStringLength("aaabc"));
+}
+@Test
+public void test2() {
+    assertEquals(3, minimizedStringLength("cbbd"));
+}
+@Test
+public void test3() {
+    assertEquals(4, minimizedStringLength("baadccab"));
+}
+
+}

minimize_string_length/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 2825,
+    "name": "minimize_string_length",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimize-string-length/",
+    "date": "2023-05-28 00:00:00",
+    "task_description": "Given a string `s`, you have two types of operation: Choose an index `i` in the string, and let `c` be the character in position `i`. **Delete** the **closest occurrence** of `c` to the **left** of `i` (if exists). Choose an index `i` in the string, and let `c` be the character in position `i`. **Delete** the **closest occurrence** of `c` to the **right** of `i` (if exists). Your task is to **minimize** the length of `s` by performing the above operations zero or more times. Return an integer denoting the length of the **minimized** string. **Example 1:** **Input:** s = \"aaabc\" **Output:** 3 **Explanation:** Operation 2: we choose `i = 1` so `c` is 'a', then we remove `s[2]` as it is closest 'a' character to the right of `s[1]`. `s` becomes \"aabc\" after this. Operation 1: we choose `i = 1` so `c` is 'a', then we remove `s[0]` as it is closest 'a' character to the left of `s[1]`. `s` becomes \"abc\" after this. **Example 2:** **Input:** s = \"cbbd\" **Output:** 3 **Explanation:** Operation 1: we choose `i = 2` so `c` is 'b', then we remove `s[1]` as it is closest 'b' character to the left of `s[1]`. `s` becomes \"cbd\" after this. **Example 3:** **Input:** s = \"baadccab\" **Output:** 4 **Explanation:** Operation 1: we choose `i = 6` so `c` is 'a', then we remove `s[2]` as it is closest 'a' character to the left of `s[6]`. `s` becomes \"badccab\" after this. Operation 2: we choose `i = 0` so `c` is 'b', then we remove `s[6]` as it is closest 'b' character to the right of `s[0]`. `s` becomes \"badcca\" fter this. Operation 2: we choose `i = 3` so `c` is 'c', then we remove `s[4]` as it is closest 'c' character to the right of `s[3]`. `s` becomes \"badca\" after this. Operation 1: we choose `i = 4` so `c` is 'a', then we remove `s[1]` as it is closest 'a' character to the left of `s[4]`. `s` becomes \"bdca\" after this. **Constraints:** `1 <= s.length <= 100` `s` contains only lowercase English letters",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"aaabc\"",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"cbbd\"",
+            "output": "3 "
+        },
+        {
+            "label": "Example 3",
+            "input": "s = \"baadccab\"",
+            "output": "4 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "tcvpsshshoempgosrmzprwdcqyjxtubmrctsxiplwhdnvnzl",
+            "output": 23
+        },
+        {
+            "input": "zbdiihopkvppoyujbpqwlazodrulomflmeektpolhnlinorgkoabhesiufhjxyouoayxffbs",
+            "output": 25
+        },
+        {
+            "input": "bfregovatvtfocylmcrvldljokensrvtuasjblfrppljuafmpanfvdvjmhijjzrevithz",
+            "output": 23
+        },
+        {
+            "input": "daokppkqwypwzrcyoxpqayzqabuxbgafmehmrmcqpowltebbzcqkgxndvblvnrxatq",
+            "output": 23
+        },
+        {
+            "input": "wqrl",
+            "output": 4
+        },
+        {
+            "input": "bprwvtx",
+            "output": 7
+        },
+        {
+            "input": "dvfhbqdwlneugchiwabnoirgaocunopshqpgldaxfmiihp",
+            "output": 21
+        },
+        {
+            "input": "gubdzicnxwzcufaeuuqxwxwyhmabtrbnritwhqulfdybxupchiqafwflmvqztiqdaaimqzhpwmkjek",
+            "output": 24
+        },
+        {
+            "input": "nmhzxfmnystrhyxclscmayjaxpwzndtnxdlseuyrkwmbumqrowyskalqpvsjexibbt",
+            "output": 25
+        },
+        {
+            "input": "ujkydxn",
+            "output": 7
+        }
+    ],
+    "haskell_template": "minimizedStringLength :: String -> Int\nminimizedStringLength s ",
+    "ocaml_template": "let minimizedStringLength (s: string) : int =  ",
+    "scala_template": "def minimizedStringLength(s: String): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimizedStringLength(String s) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimizedStringLength(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: int\n        \"\"\"\n        "
+}

minimize_string_length/ocaml_tests/main.ml

@@ -0,0 +1,51 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let minimizedStringLength (s: string) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (minimizedStringLength "aaabc")
+
+let test2 _ = assert_equal 3 (minimizedStringLength "cbbd")
+
+let test3 _ = assert_equal 4 (minimizedStringLength "baadccab")
+
+let test4 _ = assert_equal 4 (minimizedStringLength "tcvpsshshoempgosrmzprwdcqyjxtubmrctsxiplwhdnvnzl")
+
+let test5 _ = assert_equal 4 (minimizedStringLength "zbdiihopkvppoyujbpqwlazodrulomflmeektpolhnlinorgkoabhesiufhjxyouoayxffbs")
+
+let test6 _ = assert_equal 4 (minimizedStringLength "bfregovatvtfocylmcrvldljokensrvtuasjblfrppljuafmpanfvdvjmhijjzrevithz")
+
+let test7 _ = assert_equal 4 (minimizedStringLength "daokppkqwypwzrcyoxpqayzqabuxbgafmehmrmcqpowltebbzcqkgxndvblvnrxatq")
+
+let test8 _ = assert_equal 4 (minimizedStringLength "wqrl")
+
+let test9 _ = assert_equal 4 (minimizedStringLength "bprwvtx")
+
+let test10 _ = assert_equal 4 (minimizedStringLength "dvfhbqdwlneugchiwabnoirgaocunopshqpgldaxfmiihp")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimizedStringLength" >::: [
+        
+  "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

minimize_string_length/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimizedStringLength("aaabc"), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimizedStringLength("cbbd"), 3)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimizedStringLength("baadccab"), 4)
+  }
+
+  test("test4") {
+    assertEquals(Main.minimizedStringLength(",t,c,v,p,s,s,h,s,h,o,e,m,p,g,o,s,r,m,z,p,r,w,d,c,q,y,j,x,t,u,b,m,r,c,t,s,x,i,p,l,w,h,d,n,v,n,z,l,"), 23)
+  }
+
+  test("test5") {
+    assertEquals(Main.minimizedStringLength(",z,b,d,i,i,h,o,p,k,v,p,p,o,y,u,j,b,p,q,w,l,a,z,o,d,r,u,l,o,m,f,l,m,e,e,k,t,p,o,l,h,n,l,i,n,o,r,g,k,o,a,b,h,e,s,i,u,f,h,j,x,y,o,u,o,a,y,x,f,f,b,s,"), 25)
+  }
+
+  test("test6") {
+    assertEquals(Main.minimizedStringLength(",b,f,r,e,g,o,v,a,t,v,t,f,o,c,y,l,m,c,r,v,l,d,l,j,o,k,e,n,s,r,v,t,u,a,s,j,b,l,f,r,p,p,l,j,u,a,f,m,p,a,n,f,v,d,v,j,m,h,i,j,j,z,r,e,v,i,t,h,z,"), 23)
+  }
+
+  test("test7") {
+    assertEquals(Main.minimizedStringLength(",d,a,o,k,p,p,k,q,w,y,p,w,z,r,c,y,o,x,p,q,a,y,z,q,a,b,u,x,b,g,a,f,m,e,h,m,r,m,c,q,p,o,w,l,t,e,b,b,z,c,q,k,g,x,n,d,v,b,l,v,n,r,x,a,t,q,"), 23)
+  }
+
+  test("test8") {
+    assertEquals(Main.minimizedStringLength(",w,q,r,l,"), 4)
+  }
+
+  test("test9") {
+    assertEquals(Main.minimizedStringLength(",b,p,r,w,v,t,x,"), 7)
+  }
+
+  test("test10") {
+    assertEquals(Main.minimizedStringLength(",d,v,f,h,b,q,d,w,l,n,e,u,g,c,h,i,w,a,b,n,o,i,r,g,a,o,c,u,n,o,p,s,h,q,p,g,l,d,a,x,f,m,i,i,h,p,"), 21)
+  }
+
+}

minimize_the_maximum_adjacent_element_difference/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(4, minDifference(Arrays.asList(1,2,-1,10,8)));
+}
+@Test
+public void test2() {
+    assertEquals(0, minDifference(Arrays.asList(-1,-1,-1)));
+}
+@Test
+public void test3() {
+    assertEquals(1, minDifference(Arrays.asList(-1,10,-1,8)));
+}
+
+}

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

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

minimize_the_maximum_difference_of_pairs/meta.json

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

minimize_the_maximum_difference_of_pairs/ocaml_tests/main.ml

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

minimize_the_maximum_difference_of_pairs/scala_tests/MySuite.scala

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

minimize_the_maximum_edge_weight_of_graph/java_tests/Main.java

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

minimize_the_maximum_of_two_arrays/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 (minimizeSet 2 7 1 3)," 4 (minimizeSet 2 7 1 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimizeSet 3 5 2 1)," 3 (minimizeSet 3 5 2 1))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimizeSet 2 4 8 2)," 15 (minimizeSet 2 4 8 2))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimizeSet 4208 95692 390331116 307111670)," 697442792 (minimizeSet 4208 95692 390331116 307111670))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimizeSet 66767 47715 109529657 689521793)," 799051450 (minimizeSet 66767 47715 109529657 689521793))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimizeSet 66945 48742 797047732 113183367)," 910231099 (minimizeSet 66945 48742 797047732 113183367))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimizeSet 14488 22439 373499375 218898139)," 592397515 (minimizeSet 14488 22439 373499375 218898139))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimizeSet 54486 72001 372877909 182636630)," 555514539 (minimizeSet 54486 72001 372877909 182636630))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minimizeSet 79990 13730 621494960 204810810)," 826305777 (minimizeSet 79990 13730 621494960 204810810))
+
+
+-- 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

minimize_the_maximum_of_two_arrays/java_tests/Main.java

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

minimize_the_maximum_of_two_arrays/meta.json

@@ -0,0 +1,95 @@
+{
+    "id": 2628,
+    "name": "minimize_the_maximum_of_two_arrays",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimize-the-maximum-of-two-arrays/",
+    "date": "2022-12-10 00:00:00",
+    "task_description": "We have two arrays `arr1` and `arr2` which are initially empty. You need to add positive integers to them such that they satisfy all the following conditions: `arr1` contains `uniqueCnt1` **distinct** positive integers, each of which is **not divisible** by `divisor1`. `arr2` contains `uniqueCnt2` **distinct** positive integers, each of which is **not divisible** by `divisor2`. **No** integer is present in both `arr1` and `arr2`. Given `divisor1`, `divisor2`, `uniqueCnt1`, and `uniqueCnt2`, return _the **minimum possible maximum** integer that can be present in either array_. **Example 1:** ``` **Input:** divisor1 = 2, divisor2 = 7, uniqueCnt1 = 1, uniqueCnt2 = 3 **Output:** 4 **Explanation:** We can distribute the first 4 natural numbers into arr1 and arr2. arr1 = [1] and arr2 = [2,3,4]. We can see that both arrays satisfy all the conditions. Since the maximum value is 4, we return it. ``` **Example 2:** ``` **Input:** divisor1 = 3, divisor2 = 5, uniqueCnt1 = 2, uniqueCnt2 = 1 **Output:** 3 **Explanation:** Here arr1 = [1,2], and arr2 = [3] satisfy all conditions. Since the maximum value is 3, we return it. ``` **Example 3:** ``` **Input:** divisor1 = 2, divisor2 = 4, uniqueCnt1 = 8, uniqueCnt2 = 2 **Output:** 15 **Explanation:** Here, the final possible arrays can be arr1 = [1,3,5,7,9,11,13,15], and arr2 = [2,6]. It can be shown that it is not possible to obtain a lower maximum satisfying all conditions. ``` **Constraints:** `2 <= divisor1, divisor2 <= 105` `1 <= uniqueCnt1, uniqueCnt2 < 109` `2 <= uniqueCnt1 + uniqueCnt2 <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "divisor1 = 2, divisor2 = 7, uniqueCnt1 = 1, uniqueCnt2 = 3",
+            "output": "4 "
+        },
+        {
+            "label": "Example 2",
+            "input": "divisor1 = 3, divisor2 = 5, uniqueCnt1 = 2, uniqueCnt2 = 1",
+            "output": "3 "
+        },
+        {
+            "label": "Example 3",
+            "input": "divisor1 = 2, divisor2 = 4, uniqueCnt1 = 8, uniqueCnt2 = 2",
+            "output": "15 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                4208,
+                95692,
+                390331116,
+                307111670
+            ],
+            "output": 697442792
+        },
+        {
+            "input": [
+                66767,
+                47715,
+                109529657,
+                689521793
+            ],
+            "output": 799051450
+        },
+        {
+            "input": [
+                66945,
+                48742,
+                797047732,
+                113183367
+            ],
+            "output": 910231099
+        },
+        {
+            "input": [
+                14488,
+                22439,
+                373499375,
+                218898139
+            ],
+            "output": 592397515
+        },
+        {
+            "input": [
+                54486,
+                72001,
+                372877909,
+                182636630
+            ],
+            "output": 555514539
+        },
+        {
+            "input": [
+                79990,
+                13730,
+                621494960,
+                204810810
+            ],
+            "output": 826305777
+        },
+        {
+            "input": [
+                66358,
+                35001,
+                708940014,
+                188029353
+            ],
+            "output": 896969367
+        }
+    ],
+    "haskell_template": "minimizeSet :: Int -> Int -> Int -> Int -> Int\nminimizeSet divisor1 divisor2 uniqueCnt1 uniqueCnt2 ",
+    "ocaml_template": "let minimizeSet (divisor1: int) (divisor2: int) (uniqueCnt1: int) (uniqueCnt2: int) : int =  ",
+    "scala_template": "def minimizeSet(divisor1: Int,divisor2: Int,uniqueCnt1: Int,uniqueCnt2: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimizeSet(int divisor1, int divisor2, int uniqueCnt1, int uniqueCnt2) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimizeSet(self, divisor1, divisor2, uniqueCnt1, uniqueCnt2):\n        \"\"\"\n        :type divisor1: int\n        :type divisor2: int\n        :type uniqueCnt1: int\n        :type uniqueCnt2: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimize_the_maximum_of_two_arrays/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 4 (minimizeSet 2 7 1 3)
+
+let test2 _ = assert_equal 3 (minimizeSet 3 5 2 1)
+
+let test3 _ = assert_equal 15 (minimizeSet 2 4 8 2)
+
+let test4 _ = assert_equal 697442792 (minimizeSet 4208 95692 390331116 307111670)
+
+let test5 _ = assert_equal 799051450 (minimizeSet 66767 47715 109529657 689521793)
+
+let test6 _ = assert_equal 910231099 (minimizeSet 66945 48742 797047732 113183367)
+
+let test7 _ = assert_equal 592397515 (minimizeSet 14488 22439 373499375 218898139)
+
+let test8 _ = assert_equal 555514539 (minimizeSet 54486 72001 372877909 182636630)
+
+let test9 _ = assert_equal 826305777 (minimizeSet 79990 13730 621494960 204810810)
+
+let test10 _ = assert_equal 896969367 (minimizeSet 66358 35001 708940014 188029353)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimizeSet" >::: [
+        
+  "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