2169f9355af969aa9bbb73abd14c2c6a2e7408e243761b28fccb0ad8ea84a12f

.gitattributes

@@ -287,3 +287,4 @@ successful_pairs_of_spells_and_potions/meta.json filter=lfs diff=lfs merge=lfs -
 sum_of_distances/meta.json filter=lfs diff=lfs merge=lfs -text
 sum_of_matrix_after_queries/meta.json filter=lfs diff=lfs merge=lfs -text
 task_scheduler_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+total_cost_to_hire_k_workers/meta.json filter=lfs diff=lfs merge=lfs -text

time_needed_to_rearrange_a_binary_string/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 (secondsToRemoveOccurrences \"0110101 \")," 4 (secondsToRemoveOccurrences "0110101"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (secondsToRemoveOccurrences \"11100 \")," 0 (secondsToRemoveOccurrences "11100"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

time_needed_to_rearrange_a_binary_string/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(4, secondsToRemoveOccurrences("0110101"));
+}
+@Test
+public void test2() {
+    assertEquals(0, secondsToRemoveOccurrences("11100"));
+}
+
+}

time_needed_to_rearrange_a_binary_string/meta.json

@@ -0,0 +1,67 @@
+{
+    "id": 2464,
+    "name": "time_needed_to_rearrange_a_binary_string",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/time-needed-to-rearrange-a-binary-string/",
+    "date": "1659744000000",
+    "task_description": "You are given a binary string `s`. In one second, **all** occurrences of `\"01\"` are **simultaneously** replaced with `\"10\"`. This process **repeats** until no occurrences of `\"01\"` exist. Return_ the number of seconds needed to complete this process._ **Example 1:** ``` **Input:** s = \"0110101\" **Output:** 4 **Explanation:** After one second, s becomes \"1011010\". After another second, s becomes \"1101100\". After the third second, s becomes \"1110100\". After the fourth second, s becomes \"1111000\". No occurrence of \"01\" exists any longer, and the process needed 4 seconds to complete, so we return 4. ``` **Example 2:** ``` **Input:** s = \"11100\" **Output:** 0 **Explanation:** No occurrence of \"01\" exists in s, and the processes needed 0 seconds to complete, so we return 0. ``` **Constraints:** `1 <= s.length <= 1000` `s[i]` is either `'0'` or `'1'`. **Follow up:** Can you solve this problem in O(n) time complexity?",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"0110101\"",
+            "output": "4 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"11100\"",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "00000000001100100110010110001010010100011101110100111010111100000011000111111101011100000011110101001001001111001011001110001010001010000010110110111011010111001111111011100000010111110010100111110001110100010101010101001100010011100101000011111011011001001111001000100100100000111111000100001101000111010100101111010011111101001100111110111101000110100111011000101001010011100",
+            "output": 204
+        },
+        {
+            "input": "101101110011100110111111000000111100111110000011111100100011110110111110000000100011000101001000000101101100001010001011011011100110010100110101111101001000100101010011110100100000111101000100111000000111100011010000100011000001011011011100001000011110100000011000010111100110001111101001101000011101110101010110010011001011111001001010111110101011101111010101111010101111000000011010011110100110110110010001011010010100110110000001110101111011000010001001000101010100010011000100001111000001011110100001111111101111011000111100100000100010110001101101000010110011111110110101101110111100010011110101111101011001110101000111011111110001001100110001110011001011001000011100001111000001000110110011010011111011100000110001101100010010100011001011001100011010010001010100001111000001110110011110001100101100010000101110111111011010010111001010000010111101010111111100101011100001110001010110000101110100010010111001001101110101111101001111001101010011101100101000110011100100001000000010000",
+            "output": 510
+        },
+        {
+            "input": "10010011111101010110111111001111011110101100100100100011101011001011001001110001101111100",
+            "output": 53
+        },
+        {
+            "input": "1100101110101001010101010001101100001000011001000101011111000100111010101101011001001110011011010100101111101001011011010010101001110111011001111101001010110010010001001110101110111010110111101101010010100001111011101001110000110111110110110110110101010100001111011100101111110001100011111101100001100110",
+            "output": 173
+        },
+        {
+            "input": "10100000000110111000001000100100011011000011101100001100111010011001010110110011110010001110100010000110111011101100101101001011001010010101100011011101000000011101011101111010111111101010111111010011000000100011011011100111000",
+            "output": 127
+        },
+        {
+            "input": "101011101110001001010100100100010101011010101001100101011000100101110000110000010101001001001010111011100101110101000000000001000011011110111110100001110000010001101111110110111000001011111011100010010110010100111110111000001101100110010101000000100100111000100010111111001110111000101110110100111001010100010001000000100010101001001000000110010111110011000011111001101110110100110100010111000000000001111111010011010111111001011011100",
+            "output": 237
+        },
+        {
+            "input": "01011110000110010110000001100100010011100100010001111000010110010101101100101100101010010110000010100111100100100001011101110111101101010000100010110111000100010001011010000010110001000011001011100000000010011001001110100100110010110111001110001101111100010010110010100000100011101010100111011001110001111101111111110001010100011000010101010001011100001100000101100101111010000011000001100110001010110110101100001001011110101010111010011011000000001011010000001011101111001011001111001101011101011100100111111000000111010101000111110000111011000001010001100011",
+            "output": 304
+        },
+        {
+            "input": "010001001001011111000101110010001010000101000110100001110010000110010101000010001010001111011001011101010100001010110001101001001111010000001110001010000101011010011110110011001001001000011101110011101100001110010001111000011100100111100101001010111100011100110011100111110000111110110100000111111001110010100000001001101110101010101100001001100100000101101100111011010111100111100101100011000110110100010100001001010000010100111011110111001101110111101001110000010011000110110011010001111100101101011100100001011000111001100010101011110101101110100010011100011010101011100110100010110100010011001110111011000011011111001011001000001100001010011000000000100010000101001100010110010100100001000100000100100001000011010100100000111010110110101101001001101111100000100001111100010110010010111000000010001101011100100000110001101111111000000111011001001101001001001000101100101001101000011100100111111011000010010111100111100011100100011010101100001011101000000001000101110010101",
+            "output": 522
+        },
+        {
+            "input": "0100100001111010100100001011100001110110010101010100110001011110011000010000110111001000110000000010111001011111101111111000111100101101101",
+            "output": 84
+        },
+        {
+            "input": "0101011000011000100111101011110100000101000000111100100111001010011001011010100100001100010101100011101001101100001001101101000110011000100111110010101101110001001100010000110000010001110010111101100001001011010110011100111111101001100001101101111111010000011001000001011111110101111110111100101111111000101100101100101001010001111001010001111000000110010100110010100011110111011100100001111011010010101000011101111110100101110001111100111110001",
+            "output": 247
+        }
+    ],
+    "haskell_template": "secondsToRemoveOccurrences :: String -> Int\nsecondsToRemoveOccurrences s ",
+    "ocaml_template": "let secondsToRemoveOccurrences (s: string) : int =  ",
+    "scala_template": "def secondsToRemoveOccurrences(s: String): Int = { \n    \n}",
+    "java_template": "public static int secondsToRemoveOccurrences(String s) {\n\n}",
+    "python_template": "class Solution(object):\n    def secondsToRemoveOccurrences(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: int\n        \"\"\"\n        "
+}

time_needed_to_rearrange_a_binary_string/ocaml_tests/main.ml

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

time_needed_to_rearrange_a_binary_string/scala_tests/MySuite.scala

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

time_to_cross_a_bridge/java_tests/Main.java

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

total_appeal_of_a_string/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 (appealSum \"abbca \")," 28 (appealSum "abbca"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (appealSum \"code \")," 20 (appealSum "code"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

total_appeal_of_a_string/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(28, appealSum("abbca"));
+}
+@Test
+public void test2() {
+    assertEquals(20, appealSum("code"));
+}
+
+}

total_appeal_of_a_string/ocaml_tests/main.ml

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

total_appeal_of_a_string/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.appealSum("abbca"), 28)
+  }
+
+  test("test2") {
+    assertEquals(Main.appealSum("code"), 20)
+  }
+
+}

total_characters_in_string_after_transformations_i/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(7, lengthAfterTransformations("abcyy", 2));
+}
+@Test
+public void test2() {
+    assertEquals(5, lengthAfterTransformations("azbk", 1));
+}
+
+}

total_characters_in_string_after_transformations_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(7, lengthAfterTransformations("abcyy", 2, new ArrayList<>(Arrays.asList(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2))));
+}
+@Test
+public void test2() {
+    assertEquals(8, lengthAfterTransformations("azbk", 1, new ArrayList<>(Arrays.asList(2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2))));
+}
+
+}

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

total_cost_to_hire_k_workers/java_tests/Main.java

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

total_cost_to_hire_k_workers/meta.json

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

total_cost_to_hire_k_workers/ocaml_tests/main.ml

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

total_cost_to_hire_k_workers/scala_tests/MySuite.scala

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

total_distance_traveled/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 (distanceTraveled 5 10)," 60 (distanceTraveled 5 10))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (distanceTraveled 1 2)," 10 (distanceTraveled 1 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (distanceTraveled 98 21)," 1190 (distanceTraveled 98 21))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (distanceTraveled 36 37)," 440 (distanceTraveled 36 37))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (distanceTraveled 70 42)," 870 (distanceTraveled 70 42))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (distanceTraveled 75 78)," 930 (distanceTraveled 75 78))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (distanceTraveled 62 58)," 770 (distanceTraveled 62 58))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (distanceTraveled 70 95)," 870 (distanceTraveled 70 95))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (distanceTraveled 6 35)," 70 (distanceTraveled 6 35))
+
+
+-- 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

total_distance_traveled/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(60, distanceTraveled(5, 10));
+}
+@Test
+public void test2() {
+    assertEquals(10, distanceTraveled(1, 2));
+}
+
+}

total_distance_traveled/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 2857,
+    "name": "total_distance_traveled",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/total-distance-traveled/",
+    "date": "2023-06-11 00:00:00",
+    "task_description": "A truck has two fuel tanks. You are given two integers, `mainTank` representing the fuel present in the main tank in liters and `additionalTank` representing the fuel present in the additional tank in liters. The truck has a mileage of `10` km per liter. Whenever `5` liters of fuel get used up in the main tank, if the additional tank has at least `1` liters of fuel, `1` liters of fuel will be transferred from the additional tank to the main tank. Return _the maximum distance which can be traveled._ **Note: **Injection from the additional tank is not continuous. It happens suddenly and immediately for every 5 liters consumed. **Example 1:** ``` **Input:** mainTank = 5, additionalTank = 10 **Output:** 60 **Explanation:** After spending 5 litre of fuel, fuel remaining is (5 - 5 + 1) = 1 litre and distance traveled is 50km. After spending another 1 litre of fuel, no fuel gets injected in the main tank and the main tank becomes empty. Total distance traveled is 60km. ``` **Example 2:** ``` **Input:** mainTank = 1, additionalTank = 2 **Output:** 10 **Explanation:** After spending 1 litre of fuel, the main tank becomes empty. Total distance traveled is 10km. ``` **Constraints:** `1 <= mainTank, additionalTank <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "mainTank = 5, additionalTank = 10",
+            "output": "60 "
+        },
+        {
+            "label": "Example 2",
+            "input": "mainTank = 1, additionalTank = 2",
+            "output": "10 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                98,
+                21
+            ],
+            "output": 1190
+        },
+        {
+            "input": [
+                36,
+                37
+            ],
+            "output": 440
+        },
+        {
+            "input": [
+                70,
+                42
+            ],
+            "output": 870
+        },
+        {
+            "input": [
+                75,
+                78
+            ],
+            "output": 930
+        },
+        {
+            "input": [
+                62,
+                58
+            ],
+            "output": 770
+        },
+        {
+            "input": [
+                70,
+                95
+            ],
+            "output": 870
+        },
+        {
+            "input": [
+                6,
+                35
+            ],
+            "output": 70
+        },
+        {
+            "input": [
+                57,
+                55
+            ],
+            "output": 710
+        },
+        {
+            "input": [
+                70,
+                89
+            ],
+            "output": 870
+        },
+        {
+            "input": [
+                89,
+                23
+            ],
+            "output": 1110
+        }
+    ],
+    "haskell_template": "distanceTraveled :: Int -> Int -> Int\ndistanceTraveled mainTank additionalTank ",
+    "ocaml_template": "let distanceTraveled (mainTank: int) (additionalTank: int) : int =  ",
+    "scala_template": "def distanceTraveled(mainTank: Int,additionalTank: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int distanceTraveled(int mainTank, int additionalTank) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def distanceTraveled(self, mainTank, additionalTank):\n        \"\"\"\n        :type mainTank: int\n        :type additionalTank: int\n        :rtype: int\n        \"\"\"\n        "
+}

total_distance_traveled/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 60 (distanceTraveled 5 10)
+
+let test2 _ = assert_equal 10 (distanceTraveled 1 2)
+
+let test3 _ = assert_equal 1190 (distanceTraveled 98 21)
+
+let test4 _ = assert_equal 440 (distanceTraveled 36 37)
+
+let test5 _ = assert_equal 870 (distanceTraveled 70 42)
+
+let test6 _ = assert_equal 930 (distanceTraveled 75 78)
+
+let test7 _ = assert_equal 770 (distanceTraveled 62 58)
+
+let test8 _ = assert_equal 870 (distanceTraveled 70 95)
+
+let test9 _ = assert_equal 70 (distanceTraveled 6 35)
+
+let test10 _ = assert_equal 710 (distanceTraveled 57 55)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for distanceTraveled" >::: [
+        
+  "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

total_distance_traveled/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.distanceTraveled(5,10), 60)
+  }
+
+  test("test2") {
+    assertEquals(Main.distanceTraveled(1,2), 10)
+  }
+
+  test("test3") {
+    assertEquals(Main.distanceTraveled(98,21), 1190)
+  }
+
+  test("test4") {
+    assertEquals(Main.distanceTraveled(36,37), 440)
+  }
+
+  test("test5") {
+    assertEquals(Main.distanceTraveled(70,42), 870)
+  }
+
+  test("test6") {
+    assertEquals(Main.distanceTraveled(75,78), 930)
+  }
+
+  test("test7") {
+    assertEquals(Main.distanceTraveled(62,58), 770)
+  }
+
+  test("test8") {
+    assertEquals(Main.distanceTraveled(70,95), 870)
+  }
+
+  test("test9") {
+    assertEquals(Main.distanceTraveled(6,35), 70)
+  }
+
+  test("test10") {
+    assertEquals(Main.distanceTraveled(57,55), 710)
+  }
+
+}

transform_array_by_parity/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+transformArray :: [Int] -> [Int]
+transformArray nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (transformArray [4,3,2,1])," [0,0,1,1] (transformArray [4,3,2,1]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (transformArray [1,5,1,4,2])," [0,0,1,1,1] (transformArray [1,5,1,4,2]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (transformArray [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])," [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1] (transformArray [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (transformArray [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])," [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1] (transformArray [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (transformArray [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])," [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1] (transformArray [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (transformArray [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1])," [0,0,0,0,0,0,0,0,1,1,1,1] (transformArray [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (transformArray [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])," [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1] (transformArray [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

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

transform_array_by_parity/meta.json

@@ -0,0 +1,657 @@
+{
+    "id": 3778,
+    "name": "transform_array_by_parity",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/transform-array-by-parity/",
+    "date": "2025-02-15 00:00:00",
+    "task_description": "You are given an integer array `nums`. Transform `nums` by performing the following operations in the **exact** order specified: Replace each even number with 0. Replace each odd numbers with 1. Sort the modified array in **non-decreasing** order. Return the resulting array after performing these operations. **Example 1:** **Input:** nums = [4,3,2,1] **Output:** [0,0,1,1] **Explanation:** Replace the even numbers (4 and 2) with 0 and the odd numbers (3 and 1) with 1. Now, `nums = [0, 1, 0, 1]`. After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1]`. **Example 2:** **Input:** nums = [1,5,1,4,2] **Output:** [0,0,1,1,1] **Explanation:** Replace the even numbers (4 and 2) with 0 and the odd numbers (1, 5 and 1) with 1. Now, `nums = [1, 1, 1, 0, 0]`. After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1, 1]`. **Constraints:** `1 <= nums.length <= 100` `1 <= nums[i] <= 1000`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [4,3,2,1]",
+            "output": "[0,0,1,1] "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,5,1,4,2]",
+            "output": "[0,0,1,1,1] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1
+            ],
+            "output": [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1
+            ]
+        },
+        {
+            "input": [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1
+            ],
+            "output": [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1
+            ]
+        },
+        {
+            "input": [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1
+            ],
+            "output": [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1
+            ]
+        },
+        {
+            "input": [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1
+            ],
+            "output": [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1
+            ]
+        },
+        {
+            "input": [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1
+            ],
+            "output": [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1
+            ]
+        }
+    ],
+    "haskell_template": "transformArray :: [Int] -> [Int]\ntransformArray nums ",
+    "ocaml_template": "let transformArray (nums: int list) : int list =  ",
+    "scala_template": "def transformArray(nums: List[Int]): List[Int] = { \n    \n}",
+    "java_template": "class Solution {\n    public int[] transformArray(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def transformArray(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

transform_array_by_parity/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let transformArray (nums: int list) : int list =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal [0;0;1;1] (transformArray [4;3;2;1])
+
+let test2 _ = assert_equal [0;0;1;1;1] (transformArray [1;5;1;4;2])
+
+let test3 _ = assert_equal [0;0;1;1;1] (transformArray [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1])
+
+let test4 _ = assert_equal [0;0;1;1;1] (transformArray [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1])
+
+let test5 _ = assert_equal [0;0;1;1;1] (transformArray [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1])
+
+let test6 _ = assert_equal [0;0;1;1;1] (transformArray [0; 0; 0; 0; 0; 0; 0; 0; 1; 1; 1; 1])
+
+let test7 _ = assert_equal [0;0;1;1;1] (transformArray [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1; 1])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for transformArray" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

transform_array_by_parity/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.transformArray(List(4,3,2,1)), List(0,0,1,1))
+  }
+
+  test("test2") {
+    assertEquals(Main.transformArray(List(1,5,1,4,2)), List(0,0,1,1,1))
+  }
+
+  test("test3") {
+    assertEquals(Main.transformArray(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1), List(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1))
+  }
+
+  test("test4") {
+    assertEquals(Main.transformArray(0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1), List(0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1))
+  }
+
+  test("test5") {
+    assertEquals(Main.transformArray(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1), List(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1))
+  }
+
+  test("test6") {
+    assertEquals(Main.transformArray(0,0,0,0,0,0,0,0,1,1,1,1), List(0,0,0,0,0,0,0,0,1,1,1,1))
+  }
+
+  test("test7") {
+    assertEquals(Main.transformArray(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1), List(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1))
+  }
+
+}

transformed_array/haskell_tests/Main.hs

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

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

transformed_array/meta.json

@@ -0,0 +1,563 @@
+{
+    "id": 3651,
+    "name": "transformed_array",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/transformed-array/",
+    "date": "2024-12-01 00:00:00",
+    "task_description": "You are given an integer array `nums` that represents a circular array. Your task is to create a new array `result` of the **same** size, following these rules: For each index `i` (where `0 <= i < nums.length`), perform the following **independent** actions: If `nums[i] > 0`: Start at index `i` and move `nums[i]` steps to the **right** in the circular array. Set `result[i]` to the value of the index where you land. If `nums[i] < 0`: Start at index `i` and move `abs(nums[i])` steps to the **left** in the circular array. Set `result[i]` to the value of the index where you land. If `nums[i] == 0`: Set `result[i]` to `nums[i]`. Return the new array `result`. **Note:** Since `nums` is circular, moving past the last element wraps around to the beginning, and moving before the first element wraps back to the end. **Example 1:** **Input:** nums = [3,-2,1,1] **Output:** [1,1,1,3] **Explanation:** For `nums[0]` that is equal to 3, If we move 3 steps to right, we reach `nums[3]`. So `result[0]` should be 1. For `nums[1]` that is equal to -2, If we move 2 steps to left, we reach `nums[3]`. So `result[1]` should be 1. For `nums[2]` that is equal to 1, If we move 1 step to right, we reach `nums[3]`. So `result[2]` should be 1. For `nums[3]` that is equal to 1, If we move 1 step to right, we reach `nums[0]`. So `result[3]` should be 3. **Example 2:** **Input:** nums = [-1,4,-1] **Output:** [-1,-1,4] **Explanation:** For `nums[0]` that is equal to -1, If we move 1 step to left, we reach `nums[2]`. So `result[0]` should be -1. For `nums[1]` that is equal to 4, If we move 4 steps to right, we reach `nums[2]`. So `result[1]` should be -1. For `nums[2]` that is equal to -1, If we move 1 step to left, we reach `nums[1]`. So `result[2]` should be 4. **Constraints:** `1 <= nums.length <= 100` `-100 <= nums[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [3,-2,1,1]",
+            "output": "[1,1,1,3] "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [-1,4,-1]",
+            "output": "[-1,-1,4] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                20,
+                -26,
+                14,
+                -18,
+                -48,
+                74,
+                0,
+                -26,
+                -55,
+                -82,
+                19,
+                -55,
+                1,
+                -93,
+                -62,
+                -31,
+                -49,
+                -20,
+                25,
+                84,
+                -33,
+                -75,
+                59,
+                64,
+                -7,
+                5,
+                -20,
+                -89,
+                3,
+                27,
+                4,
+                -57,
+                25,
+                -38,
+                -94,
+                -15,
+                -92,
+                75,
+                -43,
+                60,
+                -74,
+                -33,
+                -35,
+                -22,
+                -5,
+                -10,
+                24,
+                80,
+                -73,
+                67,
+                -92,
+                58,
+                9,
+                -31,
+                30,
+                -56,
+                -78
+            ],
+            "output": [
+                -33,
+                25,
+                -49,
+                -35,
+                -93,
+                59,
+                0,
+                -43,
+                19,
+                -33,
+                27,
+                -93,
+                -93,
+                -94,
+                -82,
+                -33,
+                -7,
+                30,
+                -22,
+                24,
+                -5,
+                -18,
+                -7,
+                4,
+                -20,
+                4,
+                0,
+                9,
+                -57,
+                -78,
+                -94,
+                -57,
+                20,
+                9,
+                30,
+                -33,
+                -26,
+                -56,
+                9,
+                -35,
+                64,
+                -55,
+                -26,
+                -75,
+                60,
+                -15,
+                -93,
+                -93,
+                25,
+                14,
+                -31,
+                9,
+                -48,
+                59,
+                -89,
+                -78,
+                -15
+            ]
+        },
+        {
+            "input": [
+                -23,
+                42,
+                69,
+                -97,
+                -58,
+                97,
+                -47,
+                65,
+                45,
+                -93,
+                31,
+                -44,
+                -78,
+                -49,
+                81,
+                60,
+                51,
+                -80,
+                -74,
+                87,
+                20,
+                1,
+                86,
+                -32,
+                -80,
+                58,
+                -23,
+                6,
+                -92,
+                9,
+                -99,
+                -11,
+                44,
+                71,
+                56,
+                50,
+                6,
+                -64,
+                -61
+            ],
+            "output": [
+                51,
+                -58,
+                44,
+                -32,
+                -80,
+                -80,
+                -64,
+                71,
+                81,
+                71,
+                69,
+                -47,
+                -78,
+                -97,
+                -80,
+                6,
+                -92,
+                60,
+                86,
+                -92,
+                42,
+                86,
+                -99,
+                -99,
+                86,
+                97,
+                -97,
+                71,
+                81,
+                -61,
+                -93,
+                20,
+                -64,
+                -23,
+                -78,
+                65,
+                -97,
+                -78,
+                51
+            ]
+        },
+        {
+            "input": [
+                61,
+                -63,
+                -16,
+                10,
+                -39,
+                -16,
+                -95,
+                -44,
+                -16,
+                21,
+                4,
+                18,
+                -56,
+                53,
+                39,
+                69,
+                29,
+                -87,
+                43,
+                -75,
+                -81,
+                -3,
+                -66,
+                -18,
+                -73,
+                38,
+                9,
+                75,
+                -98,
+                43,
+                67,
+                -49,
+                100,
+                -9,
+                62,
+                32,
+                -13,
+                -2,
+                -81,
+                79,
+                88,
+                -1,
+                16,
+                27,
+                81,
+                -90,
+                -88,
+                15,
+                60,
+                33,
+                -20,
+                -12,
+                86,
+                20,
+                83,
+                10,
+                -55,
+                88,
+                82,
+                32,
+                98,
+                7,
+                -66,
+                60,
+                54,
+                50,
+                -42,
+                -99,
+                69,
+                -29,
+                -98,
+                -51,
+                -54,
+                65,
+                -63,
+                -16,
+                11,
+                -82
+            ],
+            "output": [
+                7,
+                29,
+                54,
+                53,
+                27,
+                -99,
+                -99,
+                -1,
+                -98,
+                67,
+                39,
+                43,
+                62,
+                -42,
+                20,
+                -95,
+                -90,
+                -16,
+                7,
+                -66,
+                -87,
+                43,
+                62,
+                -16,
+                43,
+                60,
+                32,
+                -73,
+                -16,
+                -54,
+                -75,
+                98,
+                83,
+                -73,
+                43,
+                -99,
+                -18,
+                32,
+                32,
+                88,
+                -20,
+                88,
+                82,
+                -98,
+                15,
+                -9,
+                -13,
+                -66,
+                67,
+                -39,
+                67,
+                79,
+                98,
+                65,
+                32,
+                50,
+                -63,
+                -99,
+                -66,
+                53,
+                -16,
+                69,
+                -63,
+                -90,
+                88,
+                -2,
+                -73,
+                -88,
+                32,
+                88,
+                -20,
+                -81,
+                43,
+                98,
+                18,
+                32,
+                21,
+                65
+            ]
+        },
+        {
+            "input": [
+                55,
+                -64,
+                -7,
+                -6,
+                -30,
+                -37,
+                16,
+                58,
+                57,
+                33,
+                62,
+                82,
+                -6,
+                94,
+                65,
+                0,
+                -74,
+                -32,
+                50,
+                70,
+                -85,
+                55,
+                43,
+                -70,
+                38,
+                75,
+                98,
+                86,
+                -79,
+                41,
+                -80,
+                65,
+                68,
+                -17,
+                -15,
+                -92,
+                84,
+                5,
+                -93,
+                -8,
+                -10,
+                32,
+                46,
+                40
+            ],
+            "output": [
+                82,
+                75,
+                -8,
+                32,
+                50,
+                -6,
+                43,
+                55,
+                55,
+                46,
+                -79,
+                -37,
+                16,
+                70,
+                -92,
+                0,
+                -80,
+                41,
+                38,
+                -64,
+                -70,
+                68,
+                55,
+                32,
+                50,
+                -6,
+                84,
+                75,
+                5,
+                98,
+                -93,
+                57,
+                -6,
+                -74,
+                70,
+                65,
+                68,
+                46,
+                -17,
+                65,
+                -80,
+                41,
+                55,
+                -8
+            ]
+        },
+        {
+            "input": [
+                1,
+                -93,
+                55,
+                -75,
+                27,
+                83,
+                4,
+                93,
+                -63,
+                60,
+                89,
+                46,
+                7,
+                5,
+                -67,
+                -62,
+                -49,
+                -18,
+                77,
+                2,
+                44,
+                48,
+                76,
+                -58,
+                99,
+                92,
+                -2,
+                -99,
+                -35,
+                -32,
+                -61,
+                -26,
+                49,
+                95,
+                -69
+            ],
+            "output": [
+                -93,
+                5,
+                76,
+                95,
+                -26,
+                77,
+                89,
+                -61,
+                -62,
+                -69,
+                -32,
+                76,
+                2,
+                77,
+                -18,
+                -58,
+                55,
+                -69,
+                92,
+                48,
+                -32,
+                -69,
+                -35,
+                1,
+                77,
+                7,
+                99,
+                95,
+                -35,
+                49,
+                27,
+                83,
+                46,
+                -58,
+                1
+            ]
+        }
+    ],
+    "haskell_template": "constructTransformedArray :: [Int] -> [Int]\nconstructTransformedArray nums ",
+    "ocaml_template": "let constructTransformedArray (nums: int list) : int list =  ",
+    "scala_template": "def constructTransformedArray(nums: List[Int]): List[Int] = { \n    \n}",
+    "java_template": "class Solution {\n    public int[] constructTransformedArray(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def constructTransformedArray(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

transformed_array/ocaml_tests/main.ml

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

transformed_array/scala_tests/MySuite.scala

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

unique_3_digit_even_numbers/haskell_tests/Main.hs

@@ -0,0 +1,47 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+totalNumbers :: [Int] -> Int
+totalNumbers digits = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (totalNumbers [1,2,3,4])," 12 (totalNumbers [1,2,3,4]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (totalNumbers [0,2,2])," 2 (totalNumbers [0,2,2]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (totalNumbers [6,6,6])," 1 (totalNumbers [6,6,6]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (totalNumbers [1,3,5])," 0 (totalNumbers [1,3,5]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (totalNumbers [7, 9, 2, 1])," 6 (totalNumbers [7, 9, 2, 1]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (totalNumbers [1, 7, 4, 7, 8, 4, 7, 2, 2])," 59 (totalNumbers [1, 7, 4, 7, 8, 4, 7, 2, 2]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (totalNumbers [1, 3, 1])," 0 (totalNumbers [1, 3, 1]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (totalNumbers [4, 8, 0, 3, 0, 1, 7])," 57 (totalNumbers [4, 8, 0, 3, 0, 1, 7]))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (totalNumbers [3, 3, 1, 8, 8, 5, 4, 5])," 37 (totalNumbers [3, 3, 1, 8, 8, 5, 4, 5]))
+
+
+-- 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]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

unique_3_digit_even_numbers/java_tests/Main.java

@@ -0,0 +1,28 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(12, totalNumbers(Arrays.asList(1,2,3,4)));
+}
+@Test
+public void test2() {
+    assertEquals(2, totalNumbers(Arrays.asList(0,2,2)));
+}
+@Test
+public void test3() {
+    assertEquals(1, totalNumbers(Arrays.asList(6,6,6)));
+}
+@Test
+public void test4() {
+    assertEquals(0, totalNumbers(Arrays.asList(1,3,5)));
+}
+
+}