34ae1e5a7f8612fc25f5e2e83a5971f3540b6dc3bedf0dc25d7c1eb5a8215163

.gitattributes

@@ -127,3 +127,5 @@ find_the_longest_equal_subarray/meta.json filter=lfs diff=lfs merge=lfs -text
 find_the_maximum_number_of_marked_indices/meta.json filter=lfs diff=lfs merge=lfs -text
 find_the_minimum_area_to_cover_all_ones_i/meta.json filter=lfs diff=lfs merge=lfs -text
 find_the_number_of_good_pairs_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_original_array_of_prefix_xor/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_score_of_all_prefixes_of_an_array/meta.json filter=lfs diff=lfs merge=lfs -text

find_the_original_array_of_prefix_xor/meta.json

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

find_the_original_array_of_prefix_xor/ocaml_tests/main.ml

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

find_the_original_array_of_prefix_xor/scala_tests/MySuite.scala

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

find_the_original_typed_string_ii/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, possibleStringCount("aabbccdd", 7));
+}
+@Test
+public void test2() {
+    assertEquals(1, possibleStringCount("aabbccdd", 8));
+}
+
+}

find_the_peaks/haskell_tests/Main.hs

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

find_the_peaks/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([], findPeaks(Arrays.asList(2,4,4)));
+}
+@Test
+public void test2() {
+    assertEquals(Arrays.asList(1,3), findPeaks(Arrays.asList(1,4,3,8,5)));
+}
+
+}

find_the_peaks/meta.json

@@ -0,0 +1,298 @@
+{
+    "id": 3221,
+    "name": "find_the_peaks",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/find-the-peaks/",
+    "date": "2023-11-26 00:00:00",
+    "task_description": "You are given a **0-indexed** array `mountain`. Your task is to find all the **peaks** in the `mountain` array. Return _an array that consists of _indices_ of **peaks** in the given array in **any order**._ **Notes:** A **peak** is defined as an element that is **strictly greater** than its neighboring elements. The first and last elements of the array are **not** a peak. **Example 1:** ``` **Input:** mountain = [2,4,4] **Output:** [] **Explanation:** mountain[0] and mountain[2] can not be a peak because they are first and last elements of the array. mountain[1] also can not be a peak because it is not strictly greater than mountain[2]. So the answer is []. ``` **Example 2:** ``` **Input:** mountain = [1,4,3,8,5] **Output:** [1,3] **Explanation:** mountain[0] and mountain[4] can not be a peak because they are first and last elements of the array. mountain[2] also can not be a peak because it is not strictly greater than mountain[3] and mountain[1]. But mountain [1] and mountain[3] are strictly greater than their neighboring elements. So the answer is [1,3]. ``` **Constraints:** `3 <= mountain.length <= 100` `1 <= mountain[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "mountain = [2,4,4]",
+            "output": "[] "
+        },
+        {
+            "label": "Example 2",
+            "input": "mountain = [1,4,3,8,5]",
+            "output": "[1,3] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                75,
+                5,
+                21,
+                83,
+                13,
+                67,
+                91,
+                52,
+                57,
+                19,
+                77
+            ],
+            "output": [
+                3,
+                6,
+                8
+            ]
+        },
+        {
+            "input": [
+                48,
+                55,
+                34,
+                39,
+                73,
+                63,
+                81,
+                75,
+                65,
+                54,
+                67,
+                30,
+                21,
+                76,
+                74,
+                22,
+                99,
+                39,
+                16,
+                27,
+                11,
+                12,
+                44,
+                43,
+                75,
+                87,
+                6,
+                2,
+                97,
+                63,
+                78,
+                8,
+                54,
+                2,
+                72,
+                6,
+                52,
+                43,
+                23,
+                96,
+                35,
+                71,
+                15,
+                66,
+                83,
+                27,
+                100,
+                93,
+                25,
+                53,
+                33,
+                75,
+                34,
+                80,
+                51,
+                31,
+                61,
+                82,
+                60,
+                2,
+                25,
+                87,
+                97,
+                98,
+                33,
+                10
+            ],
+            "output": [
+                1,
+                4,
+                6,
+                10,
+                13,
+                16,
+                19,
+                22,
+                25,
+                28,
+                30,
+                32,
+                34,
+                36,
+                39,
+                41,
+                44,
+                46,
+                49,
+                51,
+                53,
+                57,
+                63
+            ]
+        },
+        {
+            "input": [
+                70,
+                72,
+                65,
+                80,
+                52,
+                12,
+                20,
+                17,
+                71,
+                81,
+                85,
+                55,
+                50,
+                79,
+                98,
+                64,
+                44,
+                88,
+                43,
+                62,
+                38,
+                62,
+                57,
+                67,
+                24,
+                91,
+                23,
+                36,
+                15,
+                8,
+                48,
+                75,
+                73,
+                89,
+                92,
+                15,
+                73,
+                9,
+                59,
+                42,
+                33,
+                33,
+                4,
+                71,
+                80,
+                70,
+                8,
+                90,
+                10,
+                95,
+                99,
+                47,
+                60,
+                35,
+                33,
+                9,
+                31,
+                54,
+                12,
+                97,
+                88,
+                23,
+                7,
+                2,
+                93,
+                44,
+                94,
+                99,
+                32,
+                83,
+                20,
+                16,
+                81,
+                72,
+                26,
+                26,
+                21,
+                73,
+                80,
+                65,
+                74,
+                91,
+                91,
+                25,
+                39,
+                92,
+                78,
+                19,
+                48,
+                55,
+                59
+            ],
+            "output": [
+                1,
+                3,
+                6,
+                10,
+                14,
+                17,
+                19,
+                21,
+                23,
+                25,
+                27,
+                31,
+                34,
+                36,
+                38,
+                44,
+                47,
+                50,
+                52,
+                57,
+                59,
+                64,
+                67,
+                69,
+                72,
+                78,
+                85
+            ]
+        },
+        {
+            "input": [
+                12,
+                19,
+                89,
+                39
+            ],
+            "output": [
+                2
+            ]
+        },
+        {
+            "input": [
+                10,
+                66,
+                11,
+                86,
+                99,
+                97,
+                36,
+                22,
+                34,
+                37,
+                15,
+                94
+            ],
+            "output": [
+                1,
+                4,
+                9
+            ]
+        }
+    ],
+    "haskell_template": "findPeaks :: [Int] -> [Int]\nfindPeaks mountain ",
+    "ocaml_template": "let findPeaks (mountain: int list) : int list =  ",
+    "scala_template": "def findPeaks(mountain: List[Int]): List[Int] = { \n    \n}",
+    "java_template": "class Solution {\n    public List<Integer> findPeaks(int[] mountain) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findPeaks(self, mountain):\n        \"\"\"\n        :type mountain: List[int]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

find_the_peaks/ocaml_tests/main.ml

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

find_the_peaks/scala_tests/MySuite.scala

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

find_the_power_of_k_size_subarrays_i/java_tests/Main.java

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

find_the_power_of_k_size_subarrays_ii/java_tests/Main.java

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

find_the_prefix_common_array_of_two_arrays/java_tests/Main.java

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

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

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

find_the_safest_path_in_a_grid/meta.json

@@ -0,0 +1,31 @@
+{
+    "id": 2914,
+    "name": "find_the_safest_path_in_a_grid",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/find-the-safest-path-in-a-grid/",
+    "date": "1690675200000",
+    "task_description": "You are given a **0-indexed** 2D matrix `grid` of size `n x n`, where `(r, c)` represents: A cell containing a thief if `grid[r][c] = 1` An empty cell if `grid[r][c] = 0` You are initially positioned at cell `(0, 0)`. In one move, you can move to any adjacent cell in the grid, including cells containing thieves. The **safeness factor** of a path on the grid is defined as the **minimum** manhattan distance from any cell in the path to any thief in the grid. Return _the **maximum safeness factor** of all paths leading to cell _`(n - 1, n - 1)`_._ An **adjacent** cell of cell `(r, c)`, is one of the cells `(r, c + 1)`, `(r, c - 1)`, `(r + 1, c)` and `(r - 1, c)` if it exists. The **Manhattan distance** between two cells `(a, b)` and `(x, y)` is equal to `|a - x| + |b - y|`, where `|val|` denotes the absolute value of val. **Example 1:** ``` **Input:** grid = [[1,0,0],[0,0,0],[0,0,1]] **Output:** 0 **Explanation:** All paths from (0, 0) to (n - 1, n - 1) go through the thieves in cells (0, 0) and (n - 1, n - 1). ``` **Example 2:** ``` **Input:** grid = [[0,0,1],[0,0,0],[0,0,0]] **Output:** 2 **Explanation:** The path depicted in the picture above has a safeness factor of 2 since: - The closest cell of the path to the thief at cell (0, 2) is cell (0, 0). The distance between them is | 0 - 0 | + | 0 - 2 | = 2. It can be shown that there are no other paths with a higher safeness factor. ``` **Example 3:** ``` **Input:** grid = [[0,0,0,1],[0,0,0,0],[0,0,0,0],[1,0,0,0]] **Output:** 2 **Explanation:** The path depicted in the picture above has a safeness factor of 2 since: - The closest cell of the path to the thief at cell (0, 3) is cell (1, 2). The distance between them is | 0 - 1 | + | 3 - 2 | = 2. - The closest cell of the path to the thief at cell (3, 0) is cell (3, 2). The distance between them is | 3 - 3 | + | 0 - 2 | = 2. It can be shown that there are no other paths with a higher safeness factor. ``` **Constraints:** `1 <= grid.length == n <= 400` `grid[i].length == n` `grid[i][j]` is either `0` or `1`. There is at least one thief in the `grid`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "grid = [[1,0,0],[0,0,0],[0,0,1]]",
+            "output": "0 "
+        },
+        {
+            "label": "Example 2",
+            "input": "grid = [[0,0,1],[0,0,0],[0,0,0]]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 3",
+            "input": "grid = [[0,0,0,1],[0,0,0,0],[0,0,0,0],[1,0,0,0]]",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "maximumSafenessFactor :: [[Int]] -> Int\nmaximumSafenessFactor grid ",
+    "ocaml_template": "let maximumSafenessFactor (grid: int list list) : int =  ",
+    "scala_template": "def maximumSafenessFactor(grid: List[List[Int]]): Int = { \n    \n}",
+    "java_template": "public static int maximumSafenessFactor(List<List<Integer>> grid) {\n\n}",
+    "python_template": "class Solution(object):\n    def maximumSafenessFactor(self, grid):\n        \"\"\"\n        :type grid: List[List[int]]\n        :rtype: int\n        \"\"\"\n        "
+}

find_the_safest_path_in_a_grid/ocaml_tests/main.ml

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

find_the_safest_path_in_a_grid/scala_tests/MySuite.scala

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

find_the_score_of_all_prefixes_of_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 (findPrefixScore [2,3,7,5,10])," [4,10,24,36,56] (findPrefixScore [2,3,7,5,10]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findPrefixScore [1,1,2,4,8,16])," [2,4,8,16,32,64] (findPrefixScore [1,1,2,4,8,16]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

find_the_score_of_all_prefixes_of_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(4,10,24,36,56)), findPrefixScore(new ArrayList<>(Arrays.asList(2,3,7,5,10))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(2,4,8,16,32,64)), findPrefixScore(new ArrayList<>(Arrays.asList(1,1,2,4,8,16))));
+}
+
+}

find_the_score_of_all_prefixes_of_an_array/meta.json

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

find_the_score_of_all_prefixes_of_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 [4;10;24;36;56] (findPrefixScore [2;3;7;5;10])
+
+let test2 _ = assert_equal [2;4;8;16;32;64] (findPrefixScore [1;1;2;4;8;16])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for findPrefixScore" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

find_the_score_of_all_prefixes_of_an_array/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findPrefixScore(List(2,3,7,5,10)), List(4,10,24,36,56))
+  }
+
+  test("test2") {
+    assertEquals(Main.findPrefixScore(List(1,1,2,4,8,16)), List(2,4,8,16,32,64))
+  }
+
+}

find_the_substring_with_maximum_cost/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 (maximumCostSubstring \"adaa \"  \"d \" [-1000])," 2 (maximumCostSubstring "adaa" "d" [-1000]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maximumCostSubstring \"abc \"  \"abc \" [-1,-1,-1])," 0 (maximumCostSubstring "abc" "abc" [-1,-1,-1]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

find_the_substring_with_maximum_cost/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, maximumCostSubstring("adaa", "d", new ArrayList<>(Arrays.asList(-1000))));
+}
+@Test
+public void test2() {
+    assertEquals(0, maximumCostSubstring("abc", "abc", new ArrayList<>(Arrays.asList(-1,-1,-1))));
+}
+
+}

find_the_substring_with_maximum_cost/ocaml_tests/main.ml

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

find_the_substring_with_maximum_cost/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maximumCostSubstring("adaa","d",[-1000]), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.maximumCostSubstring("abc","abc",[-1,-1,-1]), 0)
+  }
+
+}

find_the_sum_of_encrypted_integers/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+sumOfEncryptedInt :: [Int] -> Int
+sumOfEncryptedInt nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (sumOfEncryptedInt [1,2,3])," 6 (sumOfEncryptedInt [1,2,3]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (sumOfEncryptedInt [10,21,31])," 66 (sumOfEncryptedInt [10,21,31]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (sumOfEncryptedInt [529, 735, 801, 668, 823, 372, 825, 297, 272, 429, 236, 727, 149, 130, 931, 606, 773, 656, 427, 16, 14, 63, 231, 330, 379, 938, 320, 490, 603, 106, 59, 421, 356, 348, 976, 597, 819, 913])," 27137 (sumOfEncryptedInt [529, 735, 801, 668, 823, 372, 825, 297, 272, 429, 236, 727, 149, 130, 931, 606, 773, 656, 427, 16, 14, 63, 231, 330, 379, 938, 320, 490, 603, 106, 59, 421, 356, 348, 976, 597, 819, 913]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (sumOfEncryptedInt [141, 371, 116, 440, 168, 282, 3, 893, 952, 304, 883, 707, 320])," 8550 (sumOfEncryptedInt [141, 371, 116, 440, 168, 282, 3, 893, 952, 304, 883, 707, 320]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (sumOfEncryptedInt [269, 229, 351, 250])," 3108 (sumOfEncryptedInt [269, 229, 351, 250]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (sumOfEncryptedInt [980, 926, 437, 990, 825, 97, 812, 258, 360, 769, 773])," 8979 (sumOfEncryptedInt [980, 926, 437, 990, 825, 97, 812, 258, 360, 769, 773]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (sumOfEncryptedInt [62, 259, 782, 150, 283, 92, 982, 577, 385, 317, 559])," 7935 (sumOfEncryptedInt [62, 259, 782, 150, 283, 92, 982, 577, 385, 317, 559]))
+
+
+-- 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]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

find_the_sum_of_encrypted_integers/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(6, sumOfEncryptedInt(Arrays.asList(1,2,3)));
+}
+@Test
+public void test2() {
+    assertEquals(66, sumOfEncryptedInt(Arrays.asList(10,21,31)));
+}
+
+}

find_the_sum_of_encrypted_integers/meta.json

@@ -0,0 +1,129 @@
+{
+    "id": 3367,
+    "name": "find_the_sum_of_encrypted_integers",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/find-the-sum-of-encrypted-integers/",
+    "date": "2024-03-02 00:00:00",
+    "task_description": "You are given an integer array `nums` containing **positive** integers. We define a function `encrypt` such that `encrypt(x)` replaces **every** digit in `x` with the **largest** digit in `x`. For example, `encrypt(523) = 555` and `encrypt(213) = 333`. Return _the **sum **of encrypted elements_. **Example 1:** **Input: **nums = [1,2,3] **Output: **6 **Explanation:** The encrypted elements are `[1,2,3]`. The sum of encrypted elements is `1 + 2 + 3 == 6`. **Example 2:** **Input: **nums = [10,21,31] **Output: **66 **Explanation:** The encrypted elements are `[11,22,33]`. The sum of encrypted elements is `11 + 22 + 33 == 66`. **Constraints:** `1 <= nums.length <= 50` `1 <= nums[i] <= 1000`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3]",
+            "output": "6 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [10,21,31]",
+            "output": "66 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                529,
+                735,
+                801,
+                668,
+                823,
+                372,
+                825,
+                297,
+                272,
+                429,
+                236,
+                727,
+                149,
+                130,
+                931,
+                606,
+                773,
+                656,
+                427,
+                16,
+                14,
+                63,
+                231,
+                330,
+                379,
+                938,
+                320,
+                490,
+                603,
+                106,
+                59,
+                421,
+                356,
+                348,
+                976,
+                597,
+                819,
+                913
+            ],
+            "output": 27137
+        },
+        {
+            "input": [
+                141,
+                371,
+                116,
+                440,
+                168,
+                282,
+                3,
+                893,
+                952,
+                304,
+                883,
+                707,
+                320
+            ],
+            "output": 8550
+        },
+        {
+            "input": [
+                269,
+                229,
+                351,
+                250
+            ],
+            "output": 3108
+        },
+        {
+            "input": [
+                980,
+                926,
+                437,
+                990,
+                825,
+                97,
+                812,
+                258,
+                360,
+                769,
+                773
+            ],
+            "output": 8979
+        },
+        {
+            "input": [
+                62,
+                259,
+                782,
+                150,
+                283,
+                92,
+                982,
+                577,
+                385,
+                317,
+                559
+            ],
+            "output": 7935
+        }
+    ],
+    "haskell_template": "sumOfEncryptedInt :: [Int] -> Int\nsumOfEncryptedInt nums ",
+    "ocaml_template": "let sumOfEncryptedInt (nums: int list) : int =  ",
+    "scala_template": "def sumOfEncryptedInt(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int sumOfEncryptedInt(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def sumOfEncryptedInt(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

find_the_sum_of_encrypted_integers/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let sumOfEncryptedInt (nums: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 6 (sumOfEncryptedInt [1;2;3])
+
+let test2 _ = assert_equal 66 (sumOfEncryptedInt [10;21;31])
+
+let test3 _ = assert_equal 66 (sumOfEncryptedInt [529; 735; 801; 668; 823; 372; 825; 297; 272; 429; 236; 727; 149; 130; 931; 606; 773; 656; 427; 16; 14; 63; 231; 330; 379; 938; 320; 490; 603; 106; 59; 421; 356; 348; 976; 597; 819; 913])
+
+let test4 _ = assert_equal 66 (sumOfEncryptedInt [141; 371; 116; 440; 168; 282; 3; 893; 952; 304; 883; 707; 320])
+
+let test5 _ = assert_equal 66 (sumOfEncryptedInt [269; 229; 351; 250])
+
+let test6 _ = assert_equal 66 (sumOfEncryptedInt [980; 926; 437; 990; 825; 97; 812; 258; 360; 769; 773])
+
+let test7 _ = assert_equal 66 (sumOfEncryptedInt [62; 259; 782; 150; 283; 92; 982; 577; 385; 317; 559])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for sumOfEncryptedInt" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

find_the_sum_of_encrypted_integers/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.sumOfEncryptedInt(List(1,2,3)), 6)
+  }
+
+  test("test2") {
+    assertEquals(Main.sumOfEncryptedInt(List(10,21,31)), 66)
+  }
+
+  test("test3") {
+    assertEquals(Main.sumOfEncryptedInt(529,735,801,668,823,372,825,297,272,429,236,727,149,130,931,606,773,656,427,16,14,63,231,330,379,938,320,490,603,106,59,421,356,348,976,597,819,913), 27137)
+  }
+
+  test("test4") {
+    assertEquals(Main.sumOfEncryptedInt(141,371,116,440,168,282,3,893,952,304,883,707,320), 8550)
+  }
+
+  test("test5") {
+    assertEquals(Main.sumOfEncryptedInt(269,229,351,250), 3108)
+  }
+
+  test("test6") {
+    assertEquals(Main.sumOfEncryptedInt(980,926,437,990,825,97,812,258,360,769,773), 8979)
+  }
+
+  test("test7") {
+    assertEquals(Main.sumOfEncryptedInt(62,259,782,150,283,92,982,577,385,317,559), 7935)
+  }
+
+}

find_the_sum_of_subsequence_powers/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 (sumOfPowers [1,2,3,4] 3)," 4 (sumOfPowers [1,2,3,4] 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (sumOfPowers [2,2] 2)," 0 (sumOfPowers [2,2] 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (sumOfPowers [4,3,-1] 2)," 10 (sumOfPowers [4,3,-1] 2))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (sumOfPowers [-106, ( -105), ( -86), ( -83), ( -83), ( -79), ( -78), ( -72), ( -63), ( -52), ( -40), ( -39), ( -34), ( -20), ( -16), 6, 10, 19, 39, 43, 44, 45, 45, 61, 62, 72, 75, 81, 92, 98] 27)," 108 (sumOfPowers [-106, -105, -86, -83, -83, -79, -78, -72, -63, -52, -40, -39, -34, -20, -16, 6, 10, 19, 39, 43, 44, 45, 45, 61, 62, 72, 75, 81, 92, 98] 27))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (sumOfPowers [-100, ( -92), ( -75), ( -71), ( -54), ( -31), ( -23), 19, 34, 72] 2)," 3067 (sumOfPowers [-100, -92, -75, -71, -54, -31, -23, 19, 34, 72] 2))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (sumOfPowers [-98, ( -91), ( -50), 29, 93] 4)," 110 (sumOfPowers [-98, -91, -50, 29, 93] 4))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (sumOfPowers [-105, ( -104), ( -97), ( -88), ( -67), ( -65), ( -53), ( -52), ( -51), ( -51), ( -37), ( -35), ( -34), ( -28), ( -28), ( -27), ( -27), ( -20), ( -9), ( -8), ( -7), ( -6), ( -2), ( -1), 7, 16, 18, 30, 31, 32, 32, 39, 45, 59, 64, 64, 68, 77, 82, 84, 87, 89, 94, 107] 22)," 487346736 (sumOfPowers [-105, -104, -97, -88, -67, -65, -53, -52, -51, -51, -37, -35, -34, -28, -28, -27, -27, -20, -9, -8, -7, -6, -2, -1, 7, 16, 18, 30, 31, 32, 32, 39, 45, 59, 64, 64, 68, 77, 82, 84, 87, 89, 94, 107] 22))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (sumOfPowers [-108, ( -102), ( -95), ( -90), ( -87), ( -86), ( -82), ( -80), ( -73), ( -70), ( -62), ( -37), ( -35), ( -33), ( -15), 2, 12, 19, 28, 31, 66, 70, 78, 94, 94] 22)," 617 (sumOfPowers [-108, -102, -95, -90, -87, -86, -82, -80, -73, -70, -62, -37, -35, -33, -15, 2, 12, 19, 28, 31, 66, 70, 78, 94, 94] 22))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (sumOfPowers [-106, ( -104), ( -80), ( -74), ( -62), ( -49), ( -46), ( -44), ( -9), ( -7), ( -2), 8, 14, 18, 27, 32, 35, 47, 51, 70, 84, 89] 17)," 53966 (sumOfPowers [-106, -104, -80, -74, -62, -49, -46, -44, -9, -7, -2, 8, 14, 18, 27, 32, 35, 47, 51, 70, 84, 89] 17))
+
+
+-- 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

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

find_the_sum_of_subsequence_powers/meta.json

@@ -0,0 +1,338 @@
+{
+    "id": 3316,
+    "name": "find_the_sum_of_subsequence_powers",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/find-the-sum-of-subsequence-powers/",
+    "date": "2024-03-16 00:00:00",
+    "task_description": "You are given an integer array `nums` of length `n`, and a **positive** integer `k`. The **power** of a subsequence is defined as the **minimum** absolute difference between **any** two elements in the subsequence. Return _the **sum** of **powers** of **all** subsequences of _`nums`_ which have length_ **_equal to_** `k`. Since the answer may be large, return it **modulo** `109 + 7`. **Example 1:** **Input:** nums = [1,2,3,4], k = 3 **Output:** 4 **Explanation:** There are 4 subsequences in `nums` which have length 3: `[1,2,3]`, `[1,3,4]`, `[1,2,4]`, and `[2,3,4]`. The sum of powers is `|2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4`. **Example 2:** **Input:** nums = [2,2], k = 2 **Output:** 0 **Explanation:** The only subsequence in `nums` which has length 2 is `[2,2]`. The sum of powers is `|2 - 2| = 0`. **Example 3:** **Input:** nums = [4,3,-1], k = 2 **Output:** 10 **Explanation:** There are 3 subsequences in `nums` which have length 2: `[4,3]`, `[4,-1]`, and `[3,-1]`. The sum of powers is `|4 - 3| + |4 - (-1)| + |3 - (-1)| = 10`. **Constraints:** `2 <= n == nums.length <= 50` `-108 <= nums[i] <= 108 ` `2 <= k <= n`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3,4], k = 3",
+            "output": "4 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,2], k = 2",
+            "output": "0 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [4,3,-1], k = 2",
+            "output": "10 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    -106,
+                    -105,
+                    -86,
+                    -83,
+                    -83,
+                    -79,
+                    -78,
+                    -72,
+                    -63,
+                    -52,
+                    -40,
+                    -39,
+                    -34,
+                    -20,
+                    -16,
+                    6,
+                    10,
+                    19,
+                    39,
+                    43,
+                    44,
+                    45,
+                    45,
+                    61,
+                    62,
+                    72,
+                    75,
+                    81,
+                    92,
+                    98
+                ],
+                27
+            ],
+            "output": 108
+        },
+        {
+            "input": [
+                [
+                    -100,
+                    -92,
+                    -75,
+                    -71,
+                    -54,
+                    -31,
+                    -23,
+                    19,
+                    34,
+                    72
+                ],
+                2
+            ],
+            "output": 3067
+        },
+        {
+            "input": [
+                [
+                    -98,
+                    -91,
+                    -50,
+                    29,
+                    93
+                ],
+                4
+            ],
+            "output": 110
+        },
+        {
+            "input": [
+                [
+                    -105,
+                    -104,
+                    -97,
+                    -88,
+                    -67,
+                    -65,
+                    -53,
+                    -52,
+                    -51,
+                    -51,
+                    -37,
+                    -35,
+                    -34,
+                    -28,
+                    -28,
+                    -27,
+                    -27,
+                    -20,
+                    -9,
+                    -8,
+                    -7,
+                    -6,
+                    -2,
+                    -1,
+                    7,
+                    16,
+                    18,
+                    30,
+                    31,
+                    32,
+                    32,
+                    39,
+                    45,
+                    59,
+                    64,
+                    64,
+                    68,
+                    77,
+                    82,
+                    84,
+                    87,
+                    89,
+                    94,
+                    107
+                ],
+                22
+            ],
+            "output": 487346736
+        },
+        {
+            "input": [
+                [
+                    -108,
+                    -102,
+                    -95,
+                    -90,
+                    -87,
+                    -86,
+                    -82,
+                    -80,
+                    -73,
+                    -70,
+                    -62,
+                    -37,
+                    -35,
+                    -33,
+                    -15,
+                    2,
+                    12,
+                    19,
+                    28,
+                    31,
+                    66,
+                    70,
+                    78,
+                    94,
+                    94
+                ],
+                22
+            ],
+            "output": 617
+        },
+        {
+            "input": [
+                [
+                    -106,
+                    -104,
+                    -80,
+                    -74,
+                    -62,
+                    -49,
+                    -46,
+                    -44,
+                    -9,
+                    -7,
+                    -2,
+                    8,
+                    14,
+                    18,
+                    27,
+                    32,
+                    35,
+                    47,
+                    51,
+                    70,
+                    84,
+                    89
+                ],
+                17
+            ],
+            "output": 53966
+        },
+        {
+            "input": [
+                [
+                    -92,
+                    -76,
+                    -72,
+                    -70,
+                    -29,
+                    -26,
+                    -22,
+                    -18,
+                    0,
+                    2,
+                    20,
+                    21,
+                    22,
+                    29,
+                    32,
+                    38,
+                    50,
+                    52,
+                    54,
+                    54,
+                    55,
+                    59,
+                    104,
+                    105
+                ],
+                11
+            ],
+            "output": 2872096
+        },
+        {
+            "input": [
+                [
+                    -95,
+                    -83,
+                    -81,
+                    -71,
+                    -59,
+                    -51,
+                    -48,
+                    -37,
+                    -36,
+                    -34,
+                    -24,
+                    -23,
+                    -19,
+                    -12,
+                    -9,
+                    -7,
+                    6,
+                    9,
+                    25,
+                    26,
+                    28,
+                    42,
+                    52,
+                    55,
+                    62,
+                    65,
+                    81,
+                    88,
+                    91,
+                    99,
+                    106,
+                    107
+                ],
+                21
+            ],
+            "output": 140926432
+        },
+        {
+            "input": [
+                [
+                    -108,
+                    -104,
+                    -81,
+                    -75,
+                    -37,
+                    -33,
+                    -30,
+                    -17,
+                    7,
+                    14,
+                    16,
+                    42,
+                    46,
+                    55,
+                    61,
+                    61,
+                    82,
+                    86,
+                    104,
+                    105,
+                    108
+                ],
+                6
+            ],
+            "output": 365683
+        },
+        {
+            "input": [
+                [
+                    -96,
+                    -67,
+                    -53,
+                    -24,
+                    -5,
+                    4,
+                    13,
+                    30,
+                    57,
+                    78,
+                    83,
+                    86,
+                    105
+                ],
+                4
+            ],
+            "output": 13276
+        }
+    ],
+    "haskell_template": "sumOfPowers :: [Int] -> Int -> Int\nsumOfPowers nums k ",
+    "ocaml_template": "let sumOfPowers (nums: int list) (k: int) : int =  ",
+    "scala_template": "def sumOfPowers(nums: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int sumOfPowers(int[] nums, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def sumOfPowers(self, nums, k):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

find_the_sum_of_subsequence_powers/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 4 (sumOfPowers [1;2;3;4] 3)
+
+let test2 _ = assert_equal 0 (sumOfPowers [2;2] 2)
+
+let test3 _ = assert_equal 10 (sumOfPowers [4;3;-1] 2)
+
+let test4 _ = assert_equal 108 (sumOfPowers [-106; ( -105); ( -86); ( -83); ( -83); ( -79); ( -78); ( -72); ( -63); ( -52); ( -40); ( -39); ( -34); ( -20); ( -16); 6; 10; 19; 39; 43; 44; 45; 45; 61; 62; 72; 75; 81; 92; 98] 27)
+
+let test5 _ = assert_equal 3067 (sumOfPowers [-100; ( -92); ( -75); ( -71); ( -54); ( -31); ( -23); 19; 34; 72] 2)
+
+let test6 _ = assert_equal 110 (sumOfPowers [-98; ( -91); ( -50); 29; 93] 4)
+
+let test7 _ = assert_equal 487346736 (sumOfPowers [-105; ( -104); ( -97); ( -88); ( -67); ( -65); ( -53); ( -52); ( -51); ( -51); ( -37); ( -35); ( -34); ( -28); ( -28); ( -27); ( -27); ( -20); ( -9); ( -8); ( -7); ( -6); ( -2); ( -1); 7; 16; 18; 30; 31; 32; 32; 39; 45; 59; 64; 64; 68; 77; 82; 84; 87; 89; 94; 107] 22)
+
+let test8 _ = assert_equal 617 (sumOfPowers [-108; ( -102); ( -95); ( -90); ( -87); ( -86); ( -82); ( -80); ( -73); ( -70); ( -62); ( -37); ( -35); ( -33); ( -15); 2; 12; 19; 28; 31; 66; 70; 78; 94; 94] 22)
+
+let test9 _ = assert_equal 53966 (sumOfPowers [-106; ( -104); ( -80); ( -74); ( -62); ( -49); ( -46); ( -44); ( -9); ( -7); ( -2); 8; 14; 18; 27; 32; 35; 47; 51; 70; 84; 89] 17)
+
+let test10 _ = assert_equal 2872096 (sumOfPowers [-92; ( -76); ( -72); ( -70); ( -29); ( -26); ( -22); ( -18); 0; 2; 20; 21; 22; 29; 32; 38; 50; 52; 54; 54; 55; 59; 104; 105] 11)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for sumOfPowers" >::: [
+        
+  "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

find_the_sum_of_subsequence_powers/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.sumOfPowers(List(1,2,3,4),3), 4)
+  }
+
+  test("test2") {
+    assertEquals(Main.sumOfPowers(List(2,2),2), 0)
+  }
+
+  test("test3") {
+    assertEquals(Main.sumOfPowers(List(4,3,-1),2), 10)
+  }
+
+  test("test4") {
+    assertEquals(Main.sumOfPowers(List(-106, -105, -86, -83, -83, -79, -78, -72, -63, -52, -40, -39, -34, -20, -16, 6, 10, 19, 39, 43, 44, 45, 45, 61, 62, 72, 75, 81, 92, 98),27), 108)
+  }
+
+  test("test5") {
+    assertEquals(Main.sumOfPowers(List(-100, -92, -75, -71, -54, -31, -23, 19, 34, 72),2), 3067)
+  }
+
+  test("test6") {
+    assertEquals(Main.sumOfPowers(List(-98, -91, -50, 29, 93),4), 110)
+  }
+
+  test("test7") {
+    assertEquals(Main.sumOfPowers(List(-105, -104, -97, -88, -67, -65, -53, -52, -51, -51, -37, -35, -34, -28, -28, -27, -27, -20, -9, -8, -7, -6, -2, -1, 7, 16, 18, 30, 31, 32, 32, 39, 45, 59, 64, 64, 68, 77, 82, 84, 87, 89, 94, 107),22), 487346736)
+  }
+
+  test("test8") {
+    assertEquals(Main.sumOfPowers(List(-108, -102, -95, -90, -87, -86, -82, -80, -73, -70, -62, -37, -35, -33, -15, 2, 12, 19, 28, 31, 66, 70, 78, 94, 94),22), 617)
+  }
+
+  test("test9") {
+    assertEquals(Main.sumOfPowers(List(-106, -104, -80, -74, -62, -49, -46, -44, -9, -7, -2, 8, 14, 18, 27, 32, 35, 47, 51, 70, 84, 89),17), 53966)
+  }
+
+  test("test10") {
+    assertEquals(Main.sumOfPowers(List(-92, -76, -72, -70, -29, -26, -22, -18, 0, 2, 20, 21, 22, 29, 32, 38, 50, 52, 54, 54, 55, 59, 104, 105),11), 2872096)
+  }
+
+}

find_the_sum_of_the_power_of_all_subsequences/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 (sumOfPower [1,2,3] 3)," 6 (sumOfPower [1,2,3] 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (sumOfPower [2,3,3] 5)," 4 (sumOfPower [2,3,3] 5))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (sumOfPower [1,2,3] 7)," 0 (sumOfPower [1,2,3] 7))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (sumOfPower [7248, 5128, 7789, 1275, 5420, 6934, 5119, 5373, 9374, 1981, 2257, 664, 1166, 7308, 316, 3628, 9983, 7545, 4593, 2145, 4397, 8021, 6121, 4422, 1316, 8554, 5840, 4154, 7402, 2393, 3311, 7064, 3965, 3434, 7432, 6487, 3170, 5205, 6887, 4106, 7834, 8725, 2164, 402, 3684, 7600, 7056, 9661, 8828, 9157, 8356] 81)," 0 (sumOfPower [7248, 5128, 7789, 1275, 5420, 6934, 5119, 5373, 9374, 1981, 2257, 664, 1166, 7308, 316, 3628, 9983, 7545, 4593, 2145, 4397, 8021, 6121, 4422, 1316, 8554, 5840, 4154, 7402, 2393, 3311, 7064, 3965, 3434, 7432, 6487, 3170, 5205, 6887, 4106, 7834, 8725, 2164, 402, 3684, 7600, 7056, 9661, 8828, 9157, 8356] 81))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (sumOfPower [6119, 1657, 472, 6891, 4439, 7253, 3499, 1025, 929, 6840, 4565, 9160, 1880, 1216, 165, 178, 4294, 1726, 563, 5004, 2064, 3112, 8755, 1776, 9957, 2473, 6001, 4263, 7148, 1456, 9288, 9346, 6719, 7893, 383, 7149, 7434, 3692, 2846, 5073, 1587, 1456, 1746, 547] 84)," 0 (sumOfPower [6119, 1657, 472, 6891, 4439, 7253, 3499, 1025, 929, 6840, 4565, 9160, 1880, 1216, 165, 178, 4294, 1726, 563, 5004, 2064, 3112, 8755, 1776, 9957, 2473, 6001, 4263, 7148, 1456, 9288, 9346, 6719, 7893, 383, 7149, 7434, 3692, 2846, 5073, 1587, 1456, 1746, 547] 84))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (sumOfPower [7396, 2993, 3753, 6781, 971, 2840, 1164, 8638, 6345, 7335, 9550, 7845, 2957, 9716, 5873, 200, 3525, 3860, 9215, 6783, 6625, 4773, 6703, 2503, 8471, 4507, 5949, 9626, 3351, 3245, 1857, 1472, 5988, 4944, 1194, 966, 7063, 6214, 5657, 3165, 561, 61, 5158, 5025, 8276, 795, 3456, 605, 2032, 2941, 93, 6988, 4450, 3945, 866, 5645, 1682, 4701, 8187, 4539, 5306, 8092, 7599, 369, 9813, 4265, 869, 4237, 1950, 1246, 8593, 2617, 4560, 5679, 8530, 5891] 65)," 0 (sumOfPower [7396, 2993, 3753, 6781, 971, 2840, 1164, 8638, 6345, 7335, 9550, 7845, 2957, 9716, 5873, 200, 3525, 3860, 9215, 6783, 6625, 4773, 6703, 2503, 8471, 4507, 5949, 9626, 3351, 3245, 1857, 1472, 5988, 4944, 1194, 966, 7063, 6214, 5657, 3165, 561, 61, 5158, 5025, 8276, 795, 3456, 605, 2032, 2941, 93, 6988, 4450, 3945, 866, 5645, 1682, 4701, 8187, 4539, 5306, 8092, 7599, 369, 9813, 4265, 869, 4237, 1950, 1246, 8593, 2617, 4560, 5679, 8530, 5891] 65))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (sumOfPower [9510, 4506, 5096, 4394, 8662, 4919, 7641, 5551, 6851, 3376, 3180, 1858, 8385, 9252, 3855, 4965] 37)," 0 (sumOfPower [9510, 4506, 5096, 4394, 8662, 4919, 7641, 5551, 6851, 3376, 3180, 1858, 8385, 9252, 3855, 4965] 37))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (sumOfPower [9115, 6306, 9419, 4571, 8435, 5564, 2759, 5505, 1517, 9677, 7124, 6774, 1954, 8484, 2642, 1450, 7851, 7570, 335, 4548, 3136, 5932, 8999, 5660, 7017, 406, 7162, 4047, 4817, 4576, 6803, 2406, 2847, 8910, 7312, 6670, 6095, 2712, 8576, 1098, 5038, 4376, 5135, 5210, 9776, 1229, 6138, 2592, 3689, 6229, 6227, 3555, 7955, 9069, 7196, 4426, 6969, 7830, 7892, 4345, 4001, 9754, 4661, 9376, 6509, 792, 9654, 8016, 7539, 1237, 2310, 8277, 1322, 4335, 5252, 3354, 9862, 6076, 4440, 4997, 9974, 8981, 5933, 8901, 4479, 1299, 7990, 6994, 7223, 1349, 9945, 8644, 6332, 2350, 6073, 9038, 1763, 6751, 9869] 42)," 0 (sumOfPower [9115, 6306, 9419, 4571, 8435, 5564, 2759, 5505, 1517, 9677, 7124, 6774, 1954, 8484, 2642, 1450, 7851, 7570, 335, 4548, 3136, 5932, 8999, 5660, 7017, 406, 7162, 4047, 4817, 4576, 6803, 2406, 2847, 8910, 7312, 6670, 6095, 2712, 8576, 1098, 5038, 4376, 5135, 5210, 9776, 1229, 6138, 2592, 3689, 6229, 6227, 3555, 7955, 9069, 7196, 4426, 6969, 7830, 7892, 4345, 4001, 9754, 4661, 9376, 6509, 792, 9654, 8016, 7539, 1237, 2310, 8277, 1322, 4335, 5252, 3354, 9862, 6076, 4440, 4997, 9974, 8981, 5933, 8901, 4479, 1299, 7990, 6994, 7223, 1349, 9945, 8644, 6332, 2350, 6073, 9038, 1763, 6751, 9869] 42))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (sumOfPower [2488, 7431, 4377, 6084, 2819, 7446, 7133, 5703, 8172, 9493, 5472, 2449, 372, 2481, 8492, 8694, 8110, 4954, 9731, 7990, 2063, 2804, 8105, 8167, 2685, 9883, 5971, 9019, 6984, 4723, 9368, 2628, 2283, 9252, 9318, 1667, 4881, 735, 2415, 1129, 4852, 10, 4739, 7295] 59)," 0 (sumOfPower [2488, 7431, 4377, 6084, 2819, 7446, 7133, 5703, 8172, 9493, 5472, 2449, 372, 2481, 8492, 8694, 8110, 4954, 9731, 7990, 2063, 2804, 8105, 8167, 2685, 9883, 5971, 9019, 6984, 4723, 9368, 2628, 2283, 9252, 9318, 1667, 4881, 735, 2415, 1129, 4852, 10, 4739, 7295] 59))
+
+
+-- 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

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

find_the_sum_of_the_power_of_all_subsequences/meta.json

@@ -0,0 +1,627 @@
+{
+    "id": 3345,
+    "name": "find_the_sum_of_the_power_of_all_subsequences",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/find-the-sum-of-the-power-of-all-subsequences/",
+    "date": "2024-03-02 00:00:00",
+    "task_description": "You are given an integer array `nums` of length `n` and a **positive** integer `k`. The **power** of an array of integers is defined as the number of subsequences with their sum **equal** to `k`. Return _the **sum** of **power** of all subsequences of_ `nums`_._ Since the answer may be very large, return it **modulo** `109 + 7`. **Example 1:** **Input: ** nums = [1,2,3], k = 3 **Output: ** 6 **Explanation:** There are `5` subsequences of nums with non-zero power: The subsequence `[**1**,**2**,**3**]` has `2` subsequences with `sum == 3`: `[1,2,3]` and `[1,2,3]`. The subsequence `[**1**,2,**3**]` has `1` subsequence with `sum == 3`: `[1,2,3]`. The subsequence `[1,**2**,**3**]` has `1` subsequence with `sum == 3`: `[1,2,3]`. The subsequence `[**1**,**2**,3]` has `1` subsequence with `sum == 3`: `[1,2,3]`. The subsequence `[1,2,**3**]` has `1` subsequence with `sum == 3`: `[1,2,3]`. Hence the answer is `2 + 1 + 1 + 1 + 1 = 6`. **Example 2:** **Input: ** nums = [2,3,3], k = 5 **Output: ** 4 **Explanation:** There are `3` subsequences of nums with non-zero power: The subsequence `[**2**,**3**,**3**]` has 2 subsequences with `sum == 5`: `[2,3,3]` and `[2,3,3]`. The subsequence `[**2**,3,**3**]` has 1 subsequence with `sum == 5`: `[2,3,3]`. The subsequence `[**2**,**3**,3]` has 1 subsequence with `sum == 5`: `[2,3,3]`. Hence the answer is `2 + 1 + 1 = 4`. **Example 3:** **Input: ** nums = [1,2,3], k = 7 **Output: ** 0 **Explanation: **There exists no subsequence with sum `7`. Hence all subsequences of nums have `power = 0`. **Constraints:** `1 <= n <= 100` `1 <= nums[i] <= 104` `1 <= k <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3], k = 3",
+            "output": "6 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,3,3], k = 5",
+            "output": "4 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [1,2,3], k = 7",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    7248,
+                    5128,
+                    7789,
+                    1275,
+                    5420,
+                    6934,
+                    5119,
+                    5373,
+                    9374,
+                    1981,
+                    2257,
+                    664,
+                    1166,
+                    7308,
+                    316,
+                    3628,
+                    9983,
+                    7545,
+                    4593,
+                    2145,
+                    4397,
+                    8021,
+                    6121,
+                    4422,
+                    1316,
+                    8554,
+                    5840,
+                    4154,
+                    7402,
+                    2393,
+                    3311,
+                    7064,
+                    3965,
+                    3434,
+                    7432,
+                    6487,
+                    3170,
+                    5205,
+                    6887,
+                    4106,
+                    7834,
+                    8725,
+                    2164,
+                    402,
+                    3684,
+                    7600,
+                    7056,
+                    9661,
+                    8828,
+                    9157,
+                    8356
+                ],
+                81
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    6119,
+                    1657,
+                    472,
+                    6891,
+                    4439,
+                    7253,
+                    3499,
+                    1025,
+                    929,
+                    6840,
+                    4565,
+                    9160,
+                    1880,
+                    1216,
+                    165,
+                    178,
+                    4294,
+                    1726,
+                    563,
+                    5004,
+                    2064,
+                    3112,
+                    8755,
+                    1776,
+                    9957,
+                    2473,
+                    6001,
+                    4263,
+                    7148,
+                    1456,
+                    9288,
+                    9346,
+                    6719,
+                    7893,
+                    383,
+                    7149,
+                    7434,
+                    3692,
+                    2846,
+                    5073,
+                    1587,
+                    1456,
+                    1746,
+                    547
+                ],
+                84
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    7396,
+                    2993,
+                    3753,
+                    6781,
+                    971,
+                    2840,
+                    1164,
+                    8638,
+                    6345,
+                    7335,
+                    9550,
+                    7845,
+                    2957,
+                    9716,
+                    5873,
+                    200,
+                    3525,
+                    3860,
+                    9215,
+                    6783,
+                    6625,
+                    4773,
+                    6703,
+                    2503,
+                    8471,
+                    4507,
+                    5949,
+                    9626,
+                    3351,
+                    3245,
+                    1857,
+                    1472,
+                    5988,
+                    4944,
+                    1194,
+                    966,
+                    7063,
+                    6214,
+                    5657,
+                    3165,
+                    561,
+                    61,
+                    5158,
+                    5025,
+                    8276,
+                    795,
+                    3456,
+                    605,
+                    2032,
+                    2941,
+                    93,
+                    6988,
+                    4450,
+                    3945,
+                    866,
+                    5645,
+                    1682,
+                    4701,
+                    8187,
+                    4539,
+                    5306,
+                    8092,
+                    7599,
+                    369,
+                    9813,
+                    4265,
+                    869,
+                    4237,
+                    1950,
+                    1246,
+                    8593,
+                    2617,
+                    4560,
+                    5679,
+                    8530,
+                    5891
+                ],
+                65
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    9510,
+                    4506,
+                    5096,
+                    4394,
+                    8662,
+                    4919,
+                    7641,
+                    5551,
+                    6851,
+                    3376,
+                    3180,
+                    1858,
+                    8385,
+                    9252,
+                    3855,
+                    4965
+                ],
+                37
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    9115,
+                    6306,
+                    9419,
+                    4571,
+                    8435,
+                    5564,
+                    2759,
+                    5505,
+                    1517,
+                    9677,
+                    7124,
+                    6774,
+                    1954,
+                    8484,
+                    2642,
+                    1450,
+                    7851,
+                    7570,
+                    335,
+                    4548,
+                    3136,
+                    5932,
+                    8999,
+                    5660,
+                    7017,
+                    406,
+                    7162,
+                    4047,
+                    4817,
+                    4576,
+                    6803,
+                    2406,
+                    2847,
+                    8910,
+                    7312,
+                    6670,
+                    6095,
+                    2712,
+                    8576,
+                    1098,
+                    5038,
+                    4376,
+                    5135,
+                    5210,
+                    9776,
+                    1229,
+                    6138,
+                    2592,
+                    3689,
+                    6229,
+                    6227,
+                    3555,
+                    7955,
+                    9069,
+                    7196,
+                    4426,
+                    6969,
+                    7830,
+                    7892,
+                    4345,
+                    4001,
+                    9754,
+                    4661,
+                    9376,
+                    6509,
+                    792,
+                    9654,
+                    8016,
+                    7539,
+                    1237,
+                    2310,
+                    8277,
+                    1322,
+                    4335,
+                    5252,
+                    3354,
+                    9862,
+                    6076,
+                    4440,
+                    4997,
+                    9974,
+                    8981,
+                    5933,
+                    8901,
+                    4479,
+                    1299,
+                    7990,
+                    6994,
+                    7223,
+                    1349,
+                    9945,
+                    8644,
+                    6332,
+                    2350,
+                    6073,
+                    9038,
+                    1763,
+                    6751,
+                    9869
+                ],
+                42
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    2488,
+                    7431,
+                    4377,
+                    6084,
+                    2819,
+                    7446,
+                    7133,
+                    5703,
+                    8172,
+                    9493,
+                    5472,
+                    2449,
+                    372,
+                    2481,
+                    8492,
+                    8694,
+                    8110,
+                    4954,
+                    9731,
+                    7990,
+                    2063,
+                    2804,
+                    8105,
+                    8167,
+                    2685,
+                    9883,
+                    5971,
+                    9019,
+                    6984,
+                    4723,
+                    9368,
+                    2628,
+                    2283,
+                    9252,
+                    9318,
+                    1667,
+                    4881,
+                    735,
+                    2415,
+                    1129,
+                    4852,
+                    10,
+                    4739,
+                    7295
+                ],
+                59
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    3112,
+                    3633,
+                    1372,
+                    2057
+                ],
+                90
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    2159,
+                    8059,
+                    5457,
+                    1073,
+                    2930,
+                    2332,
+                    8481,
+                    6106,
+                    3089,
+                    8998,
+                    2740,
+                    4340,
+                    96,
+                    8382,
+                    6275,
+                    2918,
+                    8951,
+                    6967,
+                    1568,
+                    2443,
+                    5919,
+                    9551,
+                    3878,
+                    4651,
+                    1809,
+                    3312,
+                    6455,
+                    6974,
+                    5135,
+                    550,
+                    9042,
+                    4928,
+                    8311,
+                    4516,
+                    8888,
+                    215,
+                    5680,
+                    3223,
+                    4643,
+                    758,
+                    1354,
+                    4224,
+                    1576,
+                    4155,
+                    9825,
+                    6360,
+                    9020,
+                    348,
+                    2649,
+                    4133,
+                    50,
+                    8576,
+                    6833,
+                    2707,
+                    1923,
+                    8343,
+                    4119,
+                    6428,
+                    7908,
+                    9491,
+                    131,
+                    1381,
+                    5168,
+                    7988,
+                    9696,
+                    7589,
+                    6136,
+                    6091,
+                    1322,
+                    4599,
+                    9982,
+                    6250,
+                    9294,
+                    8399,
+                    1524,
+                    1477,
+                    7169,
+                    9937,
+                    6008,
+                    5335,
+                    3958,
+                    5778,
+                    9744,
+                    4820,
+                    9643,
+                    1827,
+                    8457,
+                    908,
+                    2079,
+                    9153,
+                    915,
+                    2115,
+                    8444,
+                    1777,
+                    6931
+                ],
+                73
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    4281,
+                    4941,
+                    845,
+                    1334,
+                    9341,
+                    4068,
+                    3889,
+                    2916,
+                    9263,
+                    9240,
+                    4489,
+                    6320,
+                    1636,
+                    5773,
+                    2914,
+                    565,
+                    2552,
+                    4803,
+                    7241,
+                    6473,
+                    3537,
+                    9427,
+                    9198,
+                    1966,
+                    2355,
+                    9709
+                ],
+                81
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    6878,
+                    1233,
+                    342,
+                    6963,
+                    7148,
+                    9696,
+                    1965,
+                    7467,
+                    4654,
+                    5121,
+                    7970,
+                    5308,
+                    610,
+                    9237,
+                    3439,
+                    1541,
+                    565,
+                    1071,
+                    4188,
+                    1985,
+                    2705,
+                    7752,
+                    4142,
+                    4450,
+                    3942,
+                    367,
+                    7798,
+                    5673,
+                    8395,
+                    2678,
+                    3078,
+                    8420,
+                    7092,
+                    9624,
+                    5669,
+                    1921,
+                    5281,
+                    1078,
+                    3895,
+                    3704,
+                    3442,
+                    6184,
+                    5462,
+                    6231,
+                    2339,
+                    9236,
+                    5261,
+                    3025,
+                    1200,
+                    4784,
+                    2039,
+                    5150,
+                    9992,
+                    4146,
+                    4406,
+                    3647,
+                    9607,
+                    2210,
+                    9399,
+                    6129
+                ],
+                14
+            ],
+            "output": 0
+        }
+    ],
+    "haskell_template": "sumOfPower :: [Int] -> Int -> Int\nsumOfPower nums k ",
+    "ocaml_template": "let sumOfPower (nums: int list) (k: int) : int =  ",
+    "scala_template": "def sumOfPower(nums: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int sumOfPower(int[] nums, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def sumOfPower(self, nums, k):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

find_the_sum_of_the_power_of_all_subsequences/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 6 (sumOfPower [1;2;3] 3)
+
+let test2 _ = assert_equal 4 (sumOfPower [2;3;3] 5)
+
+let test3 _ = assert_equal 0 (sumOfPower [1;2;3] 7)
+
+let test4 _ = assert_equal 0 (sumOfPower [7248; 5128; 7789; 1275; 5420; 6934; 5119; 5373; 9374; 1981; 2257; 664; 1166; 7308; 316; 3628; 9983; 7545; 4593; 2145; 4397; 8021; 6121; 4422; 1316; 8554; 5840; 4154; 7402; 2393; 3311; 7064; 3965; 3434; 7432; 6487; 3170; 5205; 6887; 4106; 7834; 8725; 2164; 402; 3684; 7600; 7056; 9661; 8828; 9157; 8356] 81)
+
+let test5 _ = assert_equal 0 (sumOfPower [6119; 1657; 472; 6891; 4439; 7253; 3499; 1025; 929; 6840; 4565; 9160; 1880; 1216; 165; 178; 4294; 1726; 563; 5004; 2064; 3112; 8755; 1776; 9957; 2473; 6001; 4263; 7148; 1456; 9288; 9346; 6719; 7893; 383; 7149; 7434; 3692; 2846; 5073; 1587; 1456; 1746; 547] 84)
+
+let test6 _ = assert_equal 0 (sumOfPower [7396; 2993; 3753; 6781; 971; 2840; 1164; 8638; 6345; 7335; 9550; 7845; 2957; 9716; 5873; 200; 3525; 3860; 9215; 6783; 6625; 4773; 6703; 2503; 8471; 4507; 5949; 9626; 3351; 3245; 1857; 1472; 5988; 4944; 1194; 966; 7063; 6214; 5657; 3165; 561; 61; 5158; 5025; 8276; 795; 3456; 605; 2032; 2941; 93; 6988; 4450; 3945; 866; 5645; 1682; 4701; 8187; 4539; 5306; 8092; 7599; 369; 9813; 4265; 869; 4237; 1950; 1246; 8593; 2617; 4560; 5679; 8530; 5891] 65)
+
+let test7 _ = assert_equal 0 (sumOfPower [9510; 4506; 5096; 4394; 8662; 4919; 7641; 5551; 6851; 3376; 3180; 1858; 8385; 9252; 3855; 4965] 37)
+
+let test8 _ = assert_equal 0 (sumOfPower [9115; 6306; 9419; 4571; 8435; 5564; 2759; 5505; 1517; 9677; 7124; 6774; 1954; 8484; 2642; 1450; 7851; 7570; 335; 4548; 3136; 5932; 8999; 5660; 7017; 406; 7162; 4047; 4817; 4576; 6803; 2406; 2847; 8910; 7312; 6670; 6095; 2712; 8576; 1098; 5038; 4376; 5135; 5210; 9776; 1229; 6138; 2592; 3689; 6229; 6227; 3555; 7955; 9069; 7196; 4426; 6969; 7830; 7892; 4345; 4001; 9754; 4661; 9376; 6509; 792; 9654; 8016; 7539; 1237; 2310; 8277; 1322; 4335; 5252; 3354; 9862; 6076; 4440; 4997; 9974; 8981; 5933; 8901; 4479; 1299; 7990; 6994; 7223; 1349; 9945; 8644; 6332; 2350; 6073; 9038; 1763; 6751; 9869] 42)
+
+let test9 _ = assert_equal 0 (sumOfPower [2488; 7431; 4377; 6084; 2819; 7446; 7133; 5703; 8172; 9493; 5472; 2449; 372; 2481; 8492; 8694; 8110; 4954; 9731; 7990; 2063; 2804; 8105; 8167; 2685; 9883; 5971; 9019; 6984; 4723; 9368; 2628; 2283; 9252; 9318; 1667; 4881; 735; 2415; 1129; 4852; 10; 4739; 7295] 59)
+
+let test10 _ = assert_equal 0 (sumOfPower [3112; 3633; 1372; 2057] 90)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for sumOfPower" >::: [
+        
+  "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

find_the_sum_of_the_power_of_all_subsequences/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.sumOfPower(List(1,2,3),3), 6)
+  }
+
+  test("test2") {
+    assertEquals(Main.sumOfPower(List(2,3,3),5), 4)
+  }
+
+  test("test3") {
+    assertEquals(Main.sumOfPower(List(1,2,3),7), 0)
+  }
+
+  test("test4") {
+    assertEquals(Main.sumOfPower(List(7248, 5128, 7789, 1275, 5420, 6934, 5119, 5373, 9374, 1981, 2257, 664, 1166, 7308, 316, 3628, 9983, 7545, 4593, 2145, 4397, 8021, 6121, 4422, 1316, 8554, 5840, 4154, 7402, 2393, 3311, 7064, 3965, 3434, 7432, 6487, 3170, 5205, 6887, 4106, 7834, 8725, 2164, 402, 3684, 7600, 7056, 9661, 8828, 9157, 8356),81), 0)
+  }
+
+  test("test5") {
+    assertEquals(Main.sumOfPower(List(6119, 1657, 472, 6891, 4439, 7253, 3499, 1025, 929, 6840, 4565, 9160, 1880, 1216, 165, 178, 4294, 1726, 563, 5004, 2064, 3112, 8755, 1776, 9957, 2473, 6001, 4263, 7148, 1456, 9288, 9346, 6719, 7893, 383, 7149, 7434, 3692, 2846, 5073, 1587, 1456, 1746, 547),84), 0)
+  }
+
+  test("test6") {
+    assertEquals(Main.sumOfPower(List(7396, 2993, 3753, 6781, 971, 2840, 1164, 8638, 6345, 7335, 9550, 7845, 2957, 9716, 5873, 200, 3525, 3860, 9215, 6783, 6625, 4773, 6703, 2503, 8471, 4507, 5949, 9626, 3351, 3245, 1857, 1472, 5988, 4944, 1194, 966, 7063, 6214, 5657, 3165, 561, 61, 5158, 5025, 8276, 795, 3456, 605, 2032, 2941, 93, 6988, 4450, 3945, 866, 5645, 1682, 4701, 8187, 4539, 5306, 8092, 7599, 369, 9813, 4265, 869, 4237, 1950, 1246, 8593, 2617, 4560, 5679, 8530, 5891),65), 0)
+  }
+
+  test("test7") {
+    assertEquals(Main.sumOfPower(List(9510, 4506, 5096, 4394, 8662, 4919, 7641, 5551, 6851, 3376, 3180, 1858, 8385, 9252, 3855, 4965),37), 0)
+  }
+
+  test("test8") {
+    assertEquals(Main.sumOfPower(List(9115, 6306, 9419, 4571, 8435, 5564, 2759, 5505, 1517, 9677, 7124, 6774, 1954, 8484, 2642, 1450, 7851, 7570, 335, 4548, 3136, 5932, 8999, 5660, 7017, 406, 7162, 4047, 4817, 4576, 6803, 2406, 2847, 8910, 7312, 6670, 6095, 2712, 8576, 1098, 5038, 4376, 5135, 5210, 9776, 1229, 6138, 2592, 3689, 6229, 6227, 3555, 7955, 9069, 7196, 4426, 6969, 7830, 7892, 4345, 4001, 9754, 4661, 9376, 6509, 792, 9654, 8016, 7539, 1237, 2310, 8277, 1322, 4335, 5252, 3354, 9862, 6076, 4440, 4997, 9974, 8981, 5933, 8901, 4479, 1299, 7990, 6994, 7223, 1349, 9945, 8644, 6332, 2350, 6073, 9038, 1763, 6751, 9869),42), 0)
+  }
+
+  test("test9") {
+    assertEquals(Main.sumOfPower(List(2488, 7431, 4377, 6084, 2819, 7446, 7133, 5703, 8172, 9493, 5472, 2449, 372, 2481, 8492, 8694, 8110, 4954, 9731, 7990, 2063, 2804, 8105, 8167, 2685, 9883, 5971, 9019, 6984, 4723, 9368, 2628, 2283, 9252, 9318, 1667, 4881, 735, 2415, 1129, 4852, 10, 4739, 7295),59), 0)
+  }
+
+  test("test10") {
+    assertEquals(Main.sumOfPower(List(3112, 3633, 1372, 2057),90), 0)
+  }
+
+}