Sponsored
Sponsored
This approach involves manually iterating over each element of the array using a for loop. For each element, we apply the provided function fn with the current element and its index as arguments. The result is then pushed into a new result array, which is returned at the end.
Time Complexity: O(n), where n is the number of elements in the array.
Space Complexity: O(n) for the resultant array.
The C solution defines a function transformArray that takes an array, its size, and a function pointer. It allocates memory for a new result array, iterates over the input array, and applies the function fn, storing results in result. Finally, it returns the result array.
Another approach is to use recursion to apply the function to each element in the array. We define a recursive function that processes elements by moving from the start to the end of the array, applying transformations and constructing the result array.
Time Complexity: O(n)
Space Complexity: O(n) for result array and O(n) for function call stack.
1import java.util.ArrayList;
2import java.util.List;
3
4public class TransformArrayRecursive {
5 public static void transformArrayRecursive(int[] arr, List<Integer> result, int index, ArrFunction fn) {
6 if (index >= arr.length) return;
7 result.add(fn.apply(arr[index], index));
8 transformArrayRecursive(arr, result, index + 1, fn);
9 }
10
11 public static void main(String[] args) {
12 int[] arr = {1, 2, 3};
13 List<Integer> result = new ArrayList<>();
14 transformArrayRecursive(arr, result, 0, (n, i) -> n + 1);
15 System.out.println(result);
16 }
17}
18
19@FunctionalInterface
20interface ArrFunction {
21 int apply(int n, int i);
22}In the Java recursive approach, we use a similar recursive pattern where transformArrayRecursive applies the function to elements and forms the result list.