c75bb478d76edd30f548673176503faeda3793d5a03e5a4667861245429d1b72

.gitattributes

@@ -221,3 +221,6 @@ minimum_impossible_or/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_lines_to_represent_a_line_chart/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_money_required_before_transactions/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_number_of_coins_to_be_added/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_number_of_operations_to_make_array_xor_equal_to_k/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_number_of_operations_to_make_arrays_similar/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_number_of_operations_to_satisfy_conditions/meta.json filter=lfs diff=lfs merge=lfs -text

minimum_number_of_operations_to_make_array_xor_equal_to_k/java_tests/Main.java

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

minimum_number_of_operations_to_make_array_xor_equal_to_k/meta.json

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

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

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

minimum_number_of_operations_to_make_arrays_similar/meta.json

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

minimum_number_of_operations_to_make_arrays_similar/ocaml_tests/main.ml

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

minimum_number_of_operations_to_make_arrays_similar/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.makeSimilar(List(8,12,6),List(2,14,10)), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.makeSimilar(List(1,2,5),List(4,1,3)), 1)
+  }
+
+  test("test3") {
+    assertEquals(Main.makeSimilar(List(1,1,1,1,1),List(1,1,1,1,1)), 0)
+  }
+
+}

minimum_number_of_operations_to_make_elements_in_array_distinct/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+minimumOperations :: [Int] -> Int
+minimumOperations nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minimumOperations [1,2,3,4,2,3,3,5,7])," 2 (minimumOperations [1,2,3,4,2,3,3,5,7]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumOperations [4,5,6,4,4])," 2 (minimumOperations [4,5,6,4,4]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumOperations [6,7,8,9])," 0 (minimumOperations [6,7,8,9]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimumOperations [67, 17, 59, 80, 12, 32, 84, 64, 51, 82, 92, 54, 36, 31, 42, 21, 24, 85, 18, 47, 78, 74, 81, 76, 61, 22, 69, 88, 37, 73, 3, 23, 63, 18, 69, 7, 81, 4, 92, 90, 33, 65, 94, 79, 53, 91, 37, 36, 72, 91, 18, 97, 5, 63, 62, 41, 29, 56, 20, 24, 28, 42, 43, 96, 67, 42, 62, 75, 43, 75, 52, 90, 67, 83, 22, 38, 44])," 23 (minimumOperations [67, 17, 59, 80, 12, 32, 84, 64, 51, 82, 92, 54, 36, 31, 42, 21, 24, 85, 18, 47, 78, 74, 81, 76, 61, 22, 69, 88, 37, 73, 3, 23, 63, 18, 69, 7, 81, 4, 92, 90, 33, 65, 94, 79, 53, 91, 37, 36, 72, 91, 18, 97, 5, 63, 62, 41, 29, 56, 20, 24, 28, 42, 43, 96, 67, 42, 62, 75, 43, 75, 52, 90, 67, 83, 22, 38, 44]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimumOperations [91, 70, 32, 38, 40, 94, 88, 3, 82, 54, 28, 15, 85, 21, 82, 17, 25, 26, 13, 52, 69, 79, 70, 89, 12, 91, 71, 96, 55, 5, 17, 86, 97, 71, 68, 29, 57, 11, 35, 25, 41])," 9 (minimumOperations [91, 70, 32, 38, 40, 94, 88, 3, 82, 54, 28, 15, 85, 21, 82, 17, 25, 26, 13, 52, 69, 79, 70, 89, 12, 91, 71, 96, 55, 5, 17, 86, 97, 71, 68, 29, 57, 11, 35, 25, 41]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimumOperations [91, 66, 77, 90, 9, 73, 55, 35, 25, 55, 65, 97, 86, 8, 42, 75, 59, 10, 25, 9, 70, 80, 1, 47, 56, 53, 25, 93, 69, 18, 30])," 7 (minimumOperations [91, 66, 77, 90, 9, 73, 55, 35, 25, 55, 65, 97, 86, 8, 42, 75, 59, 10, 25, 9, 70, 80, 1, 47, 56, 53, 25, 93, 69, 18, 30]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimumOperations [16, 74, 63, 68, 63, 15, 89, 71, 24, 100, 41, 95, 28, 83, 36, 42, 46, 40, 70, 93, 10, 98, 35, 93, 70, 8, 36, 72, 40, 31, 61, 91, 16, 42, 42, 59, 20, 67, 28, 85, 29, 22, 54, 86, 49, 4, 3, 86, 42, 44, 100, 9, 26, 41, 36, 5, 19, 46, 8, 59, 63, 73, 34, 83, 4, 21, 50, 78, 25, 42, 25, 9, 53, 62, 66, 62, 32, 100, 2])," 25 (minimumOperations [16, 74, 63, 68, 63, 15, 89, 71, 24, 100, 41, 95, 28, 83, 36, 42, 46, 40, 70, 93, 10, 98, 35, 93, 70, 8, 36, 72, 40, 31, 61, 91, 16, 42, 42, 59, 20, 67, 28, 85, 29, 22, 54, 86, 49, 4, 3, 86, 42, 44, 100, 9, 26, 41, 36, 5, 19, 46, 8, 59, 63, 73, 34, 83, 4, 21, 50, 78, 25, 42, 25, 9, 53, 62, 66, 62, 32, 100, 2]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimumOperations [49, 18, 41, 58, 21, 52, 12, 14, 30, 18, 68, 92, 38, 20, 73, 78, 8, 28, 43, 46, 29, 88, 48, 65, 56, 1, 52, 62, 66, 16, 94, 15, 79, 57, 50, 59, 69, 64, 22, 25, 71, 51, 39, 6, 11, 90, 4, 29, 74, 11, 29, 75, 23, 6, 51, 12, 45, 27, 33, 17, 16, 50, 60])," 16 (minimumOperations [49, 18, 41, 58, 21, 52, 12, 14, 30, 18, 68, 92, 38, 20, 73, 78, 8, 28, 43, 46, 29, 88, 48, 65, 56, 1, 52, 62, 66, 16, 94, 15, 79, 57, 50, 59, 69, 64, 22, 25, 71, 51, 39, 6, 11, 90, 4, 29, 74, 11, 29, 75, 23, 6, 51, 12, 45, 27, 33, 17, 16, 50, 60]))
+
+
+-- 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]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_number_of_operations_to_make_elements_in_array_distinct/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(2, minimumOperations(Arrays.asList(1,2,3,4,2,3,3,5,7)));
+}
+@Test
+public void test2() {
+    assertEquals(2, minimumOperations(Arrays.asList(4,5,6,4,4)));
+}
+@Test
+public void test3() {
+    assertEquals(0, minimumOperations(Arrays.asList(6,7,8,9)));
+}
+
+}

minimum_number_of_operations_to_make_elements_in_array_distinct/meta.json

@@ -0,0 +1,348 @@
+{
+    "id": 3656,
+    "name": "minimum_number_of_operations_to_make_elements_in_array_distinct",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimum-number-of-operations-to-make-elements-in-array-distinct/",
+    "date": "2024-12-15 00:00:00",
+    "task_description": "You are given an integer array `nums`. You need to ensure that the elements in the array are **distinct**. To achieve this, you can perform the following operation any number of times: Remove 3 elements from the beginning of the array. If the array has fewer than 3 elements, remove all remaining elements. **Note** that an empty array is considered to have distinct elements. Return the **minimum** number of operations needed to make the elements in the array distinct. **Example 1:** **Input:** nums = [1,2,3,4,2,3,3,5,7] **Output:** 2 **Explanation:** In the first operation, the first 3 elements are removed, resulting in the array `[4, 2, 3, 3, 5, 7]`. In the second operation, the next 3 elements are removed, resulting in the array `[3, 5, 7]`, which has distinct elements. Therefore, the answer is 2. **Example 2:** **Input:** nums = [4,5,6,4,4] **Output:** 2 **Explanation:** In the first operation, the first 3 elements are removed, resulting in the array `[4, 4]`. In the second operation, all remaining elements are removed, resulting in an empty array. Therefore, the answer is 2. **Example 3:** **Input:** nums = [6,7,8,9] **Output:** 0 **Explanation:** The array already contains distinct elements. Therefore, the answer is 0. **Constraints:** `1 <= nums.length <= 100` `1 <= nums[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3,4,2,3,3,5,7]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [4,5,6,4,4]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [6,7,8,9]",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                67,
+                17,
+                59,
+                80,
+                12,
+                32,
+                84,
+                64,
+                51,
+                82,
+                92,
+                54,
+                36,
+                31,
+                42,
+                21,
+                24,
+                85,
+                18,
+                47,
+                78,
+                74,
+                81,
+                76,
+                61,
+                22,
+                69,
+                88,
+                37,
+                73,
+                3,
+                23,
+                63,
+                18,
+                69,
+                7,
+                81,
+                4,
+                92,
+                90,
+                33,
+                65,
+                94,
+                79,
+                53,
+                91,
+                37,
+                36,
+                72,
+                91,
+                18,
+                97,
+                5,
+                63,
+                62,
+                41,
+                29,
+                56,
+                20,
+                24,
+                28,
+                42,
+                43,
+                96,
+                67,
+                42,
+                62,
+                75,
+                43,
+                75,
+                52,
+                90,
+                67,
+                83,
+                22,
+                38,
+                44
+            ],
+            "output": 23
+        },
+        {
+            "input": [
+                91,
+                70,
+                32,
+                38,
+                40,
+                94,
+                88,
+                3,
+                82,
+                54,
+                28,
+                15,
+                85,
+                21,
+                82,
+                17,
+                25,
+                26,
+                13,
+                52,
+                69,
+                79,
+                70,
+                89,
+                12,
+                91,
+                71,
+                96,
+                55,
+                5,
+                17,
+                86,
+                97,
+                71,
+                68,
+                29,
+                57,
+                11,
+                35,
+                25,
+                41
+            ],
+            "output": 9
+        },
+        {
+            "input": [
+                91,
+                66,
+                77,
+                90,
+                9,
+                73,
+                55,
+                35,
+                25,
+                55,
+                65,
+                97,
+                86,
+                8,
+                42,
+                75,
+                59,
+                10,
+                25,
+                9,
+                70,
+                80,
+                1,
+                47,
+                56,
+                53,
+                25,
+                93,
+                69,
+                18,
+                30
+            ],
+            "output": 7
+        },
+        {
+            "input": [
+                16,
+                74,
+                63,
+                68,
+                63,
+                15,
+                89,
+                71,
+                24,
+                100,
+                41,
+                95,
+                28,
+                83,
+                36,
+                42,
+                46,
+                40,
+                70,
+                93,
+                10,
+                98,
+                35,
+                93,
+                70,
+                8,
+                36,
+                72,
+                40,
+                31,
+                61,
+                91,
+                16,
+                42,
+                42,
+                59,
+                20,
+                67,
+                28,
+                85,
+                29,
+                22,
+                54,
+                86,
+                49,
+                4,
+                3,
+                86,
+                42,
+                44,
+                100,
+                9,
+                26,
+                41,
+                36,
+                5,
+                19,
+                46,
+                8,
+                59,
+                63,
+                73,
+                34,
+                83,
+                4,
+                21,
+                50,
+                78,
+                25,
+                42,
+                25,
+                9,
+                53,
+                62,
+                66,
+                62,
+                32,
+                100,
+                2
+            ],
+            "output": 25
+        },
+        {
+            "input": [
+                49,
+                18,
+                41,
+                58,
+                21,
+                52,
+                12,
+                14,
+                30,
+                18,
+                68,
+                92,
+                38,
+                20,
+                73,
+                78,
+                8,
+                28,
+                43,
+                46,
+                29,
+                88,
+                48,
+                65,
+                56,
+                1,
+                52,
+                62,
+                66,
+                16,
+                94,
+                15,
+                79,
+                57,
+                50,
+                59,
+                69,
+                64,
+                22,
+                25,
+                71,
+                51,
+                39,
+                6,
+                11,
+                90,
+                4,
+                29,
+                74,
+                11,
+                29,
+                75,
+                23,
+                6,
+                51,
+                12,
+                45,
+                27,
+                33,
+                17,
+                16,
+                50,
+                60
+            ],
+            "output": 16
+        }
+    ],
+    "haskell_template": "minimumOperations :: [Int] -> Int\nminimumOperations nums ",
+    "ocaml_template": "let minimumOperations (nums: int list) : int =  ",
+    "scala_template": "def minimumOperations(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimumOperations(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumOperations(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_number_of_operations_to_make_elements_in_array_distinct/ocaml_tests/main.ml

@@ -0,0 +1,45 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let minimumOperations (nums: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (minimumOperations [1;2;3;4;2;3;3;5;7])
+
+let test2 _ = assert_equal 2 (minimumOperations [4;5;6;4;4])
+
+let test3 _ = assert_equal 0 (minimumOperations [6;7;8;9])
+
+let test4 _ = assert_equal 0 (minimumOperations [67; 17; 59; 80; 12; 32; 84; 64; 51; 82; 92; 54; 36; 31; 42; 21; 24; 85; 18; 47; 78; 74; 81; 76; 61; 22; 69; 88; 37; 73; 3; 23; 63; 18; 69; 7; 81; 4; 92; 90; 33; 65; 94; 79; 53; 91; 37; 36; 72; 91; 18; 97; 5; 63; 62; 41; 29; 56; 20; 24; 28; 42; 43; 96; 67; 42; 62; 75; 43; 75; 52; 90; 67; 83; 22; 38; 44])
+
+let test5 _ = assert_equal 0 (minimumOperations [91; 70; 32; 38; 40; 94; 88; 3; 82; 54; 28; 15; 85; 21; 82; 17; 25; 26; 13; 52; 69; 79; 70; 89; 12; 91; 71; 96; 55; 5; 17; 86; 97; 71; 68; 29; 57; 11; 35; 25; 41])
+
+let test6 _ = assert_equal 0 (minimumOperations [91; 66; 77; 90; 9; 73; 55; 35; 25; 55; 65; 97; 86; 8; 42; 75; 59; 10; 25; 9; 70; 80; 1; 47; 56; 53; 25; 93; 69; 18; 30])
+
+let test7 _ = assert_equal 0 (minimumOperations [16; 74; 63; 68; 63; 15; 89; 71; 24; 100; 41; 95; 28; 83; 36; 42; 46; 40; 70; 93; 10; 98; 35; 93; 70; 8; 36; 72; 40; 31; 61; 91; 16; 42; 42; 59; 20; 67; 28; 85; 29; 22; 54; 86; 49; 4; 3; 86; 42; 44; 100; 9; 26; 41; 36; 5; 19; 46; 8; 59; 63; 73; 34; 83; 4; 21; 50; 78; 25; 42; 25; 9; 53; 62; 66; 62; 32; 100; 2])
+
+let test8 _ = assert_equal 0 (minimumOperations [49; 18; 41; 58; 21; 52; 12; 14; 30; 18; 68; 92; 38; 20; 73; 78; 8; 28; 43; 46; 29; 88; 48; 65; 56; 1; 52; 62; 66; 16; 94; 15; 79; 57; 50; 59; 69; 64; 22; 25; 71; 51; 39; 6; 11; 90; 4; 29; 74; 11; 29; 75; 23; 6; 51; 12; 45; 27; 33; 17; 16; 50; 60])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumOperations" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

minimum_number_of_operations_to_make_elements_in_array_distinct/scala_tests/MySuite.scala

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

minimum_number_of_operations_to_make_word_k_periodic/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, minimumOperationsToMakeKPeriodic("leetcodeleet", 4));
+}
+@Test
+public void test2() {
+    assertEquals(3, minimumOperationsToMakeKPeriodic(" leetcoleet ", 2));
+}
+
+}

minimum_number_of_operations_to_make_x_and_y_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 (minimumOperationsToMakeEqual 26 1)," 3 (minimumOperationsToMakeEqual 26 1))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumOperationsToMakeEqual 54 2)," 4 (minimumOperationsToMakeEqual 54 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumOperationsToMakeEqual 25 30)," 5 (minimumOperationsToMakeEqual 25 30))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimumOperationsToMakeEqual 6266 3684)," 2433 (minimumOperationsToMakeEqual 6266 3684))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimumOperationsToMakeEqual 2531 2524)," 7 (minimumOperationsToMakeEqual 2531 2524))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimumOperationsToMakeEqual 6102 3286)," 2069 (minimumOperationsToMakeEqual 6102 3286))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimumOperationsToMakeEqual 5781 8456)," 2675 (minimumOperationsToMakeEqual 5781 8456))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimumOperationsToMakeEqual 8010 279)," 45 (minimumOperationsToMakeEqual 8010 279))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minimumOperationsToMakeEqual 7279 648)," 18 (minimumOperationsToMakeEqual 7279 648))
+
+
+-- 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

minimum_number_of_operations_to_make_x_and_y_equal/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, minimumOperationsToMakeEqual(26, 1));
+}
+@Test
+public void test2() {
+    assertEquals(4, minimumOperationsToMakeEqual(54, 2));
+}
+@Test
+public void test3() {
+    assertEquals(5, minimumOperationsToMakeEqual(25, 30));
+}
+
+}

minimum_number_of_operations_to_make_x_and_y_equal/meta.json

@@ -0,0 +1,102 @@
+{
+    "id": 3239,
+    "name": "minimum_number_of_operations_to_make_x_and_y_equal",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-number-of-operations-to-make-x-and-y-equal/",
+    "date": "2023-12-23 00:00:00",
+    "task_description": "You are given two positive integers `x` and `y`. In one operation, you can do one of the four following operations: Divide `x` by `11` if `x` is a multiple of `11`. Divide `x` by `5` if `x` is a multiple of `5`. Decrement `x` by `1`. Increment `x` by `1`. Return _the **minimum** number of operations required to make _ `x` and `y` equal. **Example 1:** ``` **Input:** x = 26, y = 1 **Output:** 3 **Explanation:** We can make 26 equal to 1 by applying the following operations: 1. Decrement x by 1 2. Divide x by 5 3. Divide x by 5 It can be shown that 3 is the minimum number of operations required to make 26 equal to 1. ``` **Example 2:** ``` **Input:** x = 54, y = 2 **Output:** 4 **Explanation:** We can make 54 equal to 2 by applying the following operations: 1. Increment x by 1 2. Divide x by 11 3. Divide x by 5 4. Increment x by 1 It can be shown that 4 is the minimum number of operations required to make 54 equal to 2. ``` **Example 3:** ``` **Input:** x = 25, y = 30 **Output:** 5 **Explanation:** We can make 25 equal to 30 by applying the following operations: 1. Increment x by 1 2. Increment x by 1 3. Increment x by 1 4. Increment x by 1 5. Increment x by 1 It can be shown that 5 is the minimum number of operations required to make 25 equal to 30. ``` **Constraints:** `1 <= x, y <= 104`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "x = 26, y = 1",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "x = 54, y = 2",
+            "output": "4 "
+        },
+        {
+            "label": "Example 3",
+            "input": "x = 25, y = 30",
+            "output": "5 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                6266,
+                3684
+            ],
+            "output": 2433
+        },
+        {
+            "input": [
+                2531,
+                2524
+            ],
+            "output": 7
+        },
+        {
+            "input": [
+                6102,
+                3286
+            ],
+            "output": 2069
+        },
+        {
+            "input": [
+                5781,
+                8456
+            ],
+            "output": 2675
+        },
+        {
+            "input": [
+                8010,
+                279
+            ],
+            "output": 45
+        },
+        {
+            "input": [
+                7279,
+                648
+            ],
+            "output": 18
+        },
+        {
+            "input": [
+                4579,
+                2883
+            ],
+            "output": 1696
+        },
+        {
+            "input": [
+                8696,
+                4573
+            ],
+            "output": 2836
+        },
+        {
+            "input": [
+                8343,
+                7156
+            ],
+            "output": 1187
+        },
+        {
+            "input": [
+                4572,
+                8515
+            ],
+            "output": 3943
+        }
+    ],
+    "haskell_template": "minimumOperationsToMakeEqual :: Int -> Int -> Int\nminimumOperationsToMakeEqual x y ",
+    "ocaml_template": "let minimumOperationsToMakeEqual (x: int) (y: int) : int =  ",
+    "scala_template": "def minimumOperationsToMakeEqual(x: Int,y: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimumOperationsToMakeEqual(int x, int y) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumOperationsToMakeEqual(self, x, y):\n        \"\"\"\n        :type x: int\n        :type y: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_number_of_operations_to_make_x_and_y_equal/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (minimumOperationsToMakeEqual 26 1)
+
+let test2 _ = assert_equal 4 (minimumOperationsToMakeEqual 54 2)
+
+let test3 _ = assert_equal 5 (minimumOperationsToMakeEqual 25 30)
+
+let test4 _ = assert_equal 2433 (minimumOperationsToMakeEqual 6266 3684)
+
+let test5 _ = assert_equal 7 (minimumOperationsToMakeEqual 2531 2524)
+
+let test6 _ = assert_equal 2069 (minimumOperationsToMakeEqual 6102 3286)
+
+let test7 _ = assert_equal 2675 (minimumOperationsToMakeEqual 5781 8456)
+
+let test8 _ = assert_equal 45 (minimumOperationsToMakeEqual 8010 279)
+
+let test9 _ = assert_equal 18 (minimumOperationsToMakeEqual 7279 648)
+
+let test10 _ = assert_equal 1696 (minimumOperationsToMakeEqual 4579 2883)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumOperationsToMakeEqual" >::: [
+        
+  "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

minimum_number_of_operations_to_make_x_and_y_equal/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumOperationsToMakeEqual(26,1), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumOperationsToMakeEqual(54,2), 4)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumOperationsToMakeEqual(25,30), 5)
+  }
+
+  test("test4") {
+    assertEquals(Main.minimumOperationsToMakeEqual(6266,3684), 2433)
+  }
+
+  test("test5") {
+    assertEquals(Main.minimumOperationsToMakeEqual(2531,2524), 7)
+  }
+
+  test("test6") {
+    assertEquals(Main.minimumOperationsToMakeEqual(6102,3286), 2069)
+  }
+
+  test("test7") {
+    assertEquals(Main.minimumOperationsToMakeEqual(5781,8456), 2675)
+  }
+
+  test("test8") {
+    assertEquals(Main.minimumOperationsToMakeEqual(8010,279), 45)
+  }
+
+  test("test9") {
+    assertEquals(Main.minimumOperationsToMakeEqual(7279,648), 18)
+  }
+
+  test("test10") {
+    assertEquals(Main.minimumOperationsToMakeEqual(4579,2883), 1696)
+  }
+
+}

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

minimum_number_of_operations_to_satisfy_conditions/meta.json

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

minimum_number_of_pushes_to_type_word_i/haskell_tests/Main.hs

@@ -0,0 +1,47 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+minimumPushes :: String -> Int
+minimumPushes word = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minimumPushes \"abcde \")," 5 (minimumPushes "abcde"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumPushes \"xycdefghij \")," 12 (minimumPushes "xycdefghij"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumPushes  \"ytpmlveqaorscn \")," 20 (minimumPushes "ytpmlveqaorscn"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimumPushes  \"oabctkjnyrqlvsfmgwux \")," 36 (minimumPushes "oabctkjnyrqlvsfmgwux"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimumPushes  \"fzrqwode \")," 8 (minimumPushes "fzrqwode"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimumPushes  \"gcnmiyrdhzvk \")," 16 (minimumPushes "gcnmiyrdhzvk"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimumPushes  \"kpsahebnwdo \")," 14 (minimumPushes "kpsahebnwdo"))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimumPushes  \"suvwdacbqxpkrgiyftl \")," 33 (minimumPushes "suvwdacbqxpkrgiyftl"))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minimumPushes  \"kefduqyzhgsxialp \")," 24 (minimumPushes "kefduqyzhgsxialp"))
+
+
+-- 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

minimum_number_of_pushes_to_type_word_i/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(5, minimumPushes("abcde"));
+}
+@Test
+public void test2() {
+    assertEquals(12, minimumPushes("xycdefghij"));
+}
+
+}

minimum_number_of_pushes_to_type_word_i/meta.json

@@ -0,0 +1,67 @@
+{
+    "id": 3275,
+    "name": "minimum_number_of_pushes_to_type_word_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimum-number-of-pushes-to-type-word-i/",
+    "date": "2024-01-14 00:00:00",
+    "task_description": "You are given a string `word` containing **distinct** lowercase English letters. Telephone keypads have keys mapped with **distinct** collections of lowercase English letters, which can be used to form words by pushing them. For example, the key `2` is mapped with `[\"a\",\"b\",\"c\"]`, we need to push the key one time to type `\"a\"`, two times to type `\"b\"`, and three times to type `\"c\"` _._ It is allowed to remap the keys numbered `2` to `9` to **distinct** collections of letters. The keys can be remapped to **any** amount of letters, but each letter **must** be mapped to **exactly** one key. You need to find the **minimum** number of times the keys will be pushed to type the string `word`. Return _the **minimum** number of pushes needed to type _`word` _after remapping the keys_. An example mapping of letters to keys on a telephone keypad is given below. Note that `1`, `*`, `#`, and `0` do **not** map to any letters. **Example 1:** ``` **Input:** word = \"abcde\" **Output:** 5 **Explanation:** The remapped keypad given in the image provides the minimum cost. \"a\" -> one push on key 2 \"b\" -> one push on key 3 \"c\" -> one push on key 4 \"d\" -> one push on key 5 \"e\" -> one push on key 6 Total cost is 1 + 1 + 1 + 1 + 1 = 5. It can be shown that no other mapping can provide a lower cost. ``` **Example 2:** ``` **Input:** word = \"xycdefghij\" **Output:** 12 **Explanation:** The remapped keypad given in the image provides the minimum cost. \"x\" -> one push on key 2 \"y\" -> two pushes on key 2 \"c\" -> one push on key 3 \"d\" -> two pushes on key 3 \"e\" -> one push on key 4 \"f\" -> one push on key 5 \"g\" -> one push on key 6 \"h\" -> one push on key 7 \"i\" -> one push on key 8 \"j\" -> one push on key 9 Total cost is 1 + 2 + 1 + 2 + 1 + 1 + 1 + 1 + 1 + 1 = 12. It can be shown that no other mapping can provide a lower cost. ``` **Constraints:** `1 <= word.length <= 26` `word` consists of lowercase English letters. All letters in `word` are distinct.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "word = \"abcde\"",
+            "output": "5 "
+        },
+        {
+            "label": "Example 2",
+            "input": "word = \"xycdefghij\"",
+            "output": "12 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "ytpmlveqaorscn",
+            "output": 20
+        },
+        {
+            "input": "oabctkjnyrqlvsfmgwux",
+            "output": 36
+        },
+        {
+            "input": "fzrqwode",
+            "output": 8
+        },
+        {
+            "input": "gcnmiyrdhzvk",
+            "output": 16
+        },
+        {
+            "input": "kpsahebnwdo",
+            "output": 14
+        },
+        {
+            "input": "suvwdacbqxpkrgiyftl",
+            "output": 33
+        },
+        {
+            "input": "kefduqyzhgsxialp",
+            "output": 24
+        },
+        {
+            "input": "dra",
+            "output": 3
+        },
+        {
+            "input": "djvt",
+            "output": 4
+        },
+        {
+            "input": "bzimqfatksyuoer",
+            "output": 22
+        }
+    ],
+    "haskell_template": "minimumPushes :: String -> Int\nminimumPushes word ",
+    "ocaml_template": "let minimumPushes (word: string) : int =  ",
+    "scala_template": "def minimumPushes(word: String): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimumPushes(String word) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumPushes(self, word):\n        \"\"\"\n        :type word: str\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_number_of_pushes_to_type_word_i/ocaml_tests/main.ml

@@ -0,0 +1,51 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let minimumPushes (word: string) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 5 (minimumPushes "abcde")
+
+let test2 _ = assert_equal 12 (minimumPushes "xycdefghij")
+
+let test3 _ = assert_equal 12 (minimumPushes "ytpmlveqaorscn")
+
+let test4 _ = assert_equal 12 (minimumPushes "oabctkjnyrqlvsfmgwux")
+
+let test5 _ = assert_equal 12 (minimumPushes "fzrqwode")
+
+let test6 _ = assert_equal 12 (minimumPushes "gcnmiyrdhzvk")
+
+let test7 _ = assert_equal 12 (minimumPushes "kpsahebnwdo")
+
+let test8 _ = assert_equal 12 (minimumPushes "suvwdacbqxpkrgiyftl")
+
+let test9 _ = assert_equal 12 (minimumPushes "kefduqyzhgsxialp")
+
+let test10 _ = assert_equal 12 (minimumPushes "dra")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumPushes" >::: [
+        
+  "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

minimum_number_of_pushes_to_type_word_i/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumPushes("abcde"), 5)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumPushes("xycdefghij"), 12)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumPushes(",y,t,p,m,l,v,e,q,a,o,r,s,c,n,"), 20)
+  }
+
+  test("test4") {
+    assertEquals(Main.minimumPushes(",o,a,b,c,t,k,j,n,y,r,q,l,v,s,f,m,g,w,u,x,"), 36)
+  }
+
+  test("test5") {
+    assertEquals(Main.minimumPushes(",f,z,r,q,w,o,d,e,"), 8)
+  }
+
+  test("test6") {
+    assertEquals(Main.minimumPushes(",g,c,n,m,i,y,r,d,h,z,v,k,"), 16)
+  }
+
+  test("test7") {
+    assertEquals(Main.minimumPushes(",k,p,s,a,h,e,b,n,w,d,o,"), 14)
+  }
+
+  test("test8") {
+    assertEquals(Main.minimumPushes(",s,u,v,w,d,a,c,b,q,x,p,k,r,g,i,y,f,t,l,"), 33)
+  }
+
+  test("test9") {
+    assertEquals(Main.minimumPushes(",k,e,f,d,u,q,y,z,h,g,s,x,i,a,l,p,"), 24)
+  }
+
+  test("test10") {
+    assertEquals(Main.minimumPushes(",d,r,a,"), 3)
+  }
+
+}

minimum_number_of_pushes_to_type_word_ii/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(5, minimumPushes("abcde"));
+}
+@Test
+public void test2() {
+    assertEquals(12, minimumPushes("xyzxyzxyzxyz"));
+}
+@Test
+public void test3() {
+    assertEquals(24, minimumPushes("aabbccddeeffgghhiiiiii"));
+}
+
+}

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