Hello there! Are you ready to solve another engaging problem today? We have a practical task that will enhance your problem-solving skills. It involves critical aspects of programming — dealing with arrays and using techniques such as sorting and the two-pointer method. So, let's jump in!
Task Statement
Solution Building: Step 1
Let's embark on our solution-building journey by constructing a sorted array for array B. This array will include pairs of values (val) and their corresponding indices (idx) from array B. Here, val represents the element in B, while idx denotes the index at which val is found in array B.
This sorted array will be similar to an associative array, storing 'value-index' pairs. It not only organizes the data for efficient retrieval but also makes it easier for us to traverse the array. Here's the introductory part of our Java function, including the complete sorted array:
Java
import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.Comparator;import java.util.List;import java.util.AbstractMap.SimpleEntry;public class FindAndReplace { public static int[] findAndReplace(int[] A, int[] B) { List<SimpleEntry<Integer, Integer>> B_sorted = new ArrayList<>(); for (int i = 0; i < B.length; i++) { B_sorted.add(new SimpleEntry<>(B[i], i)); } B_sorted.sort(Comparator.comparingInt(SimpleEntry::getKey));
In the above code, we generate an array of pairs comprising the values from B and their respective indices using a simple loop. Then, the sort function arranges these pairs in ascending order of their values.
Join the 1M+ learners on CodeSignal
Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal
Alright, our task is as follows. Suppose you have two equally long arrays, A and B, with a length varying from 1 to 1000, with each element being a unique positive integer ranging from 1 up to 106. Your challenge is to craft a Java function that identifies the closest number in array B to 2⋅B[i] for each i. Once this number is identified, say, for the specific i, it is B[j]. We want to create an array from A[j]s in the order of increasing i.
To illustrate this, let's consider an example. We have:
The first item in B is 4 at index=0. Double this number is 8. The closest number to 8 in array B is 8, which is at index=7. The number at the same index in array A is 80, so we add 80 to our new array.
The second item in B is 12 at index=1. Double this number is 24. The closest number to 24 in B is 25, which is at index=9. The corresponding index in A has the number 100. So, we add 100 to our new array.
The third item in B is 3 at index=2. Double this number is 6. The closest number to 6 in B is 6, which is at index=4. The corresponding index in A has the number 50. So, we add 50 to our new array.
We continue this process for the rest of the elements in B.
Now that our sorted array (or associative array) is ready, we initiate the right pointer, j, and the result array, res. The former assists in ensuring our search remains within the boundaries of B_sorted, while the latter will be our final output containing the replaced elements from array A. We'll update res as we progress through the solution.
public static int[] findAndReplace(int[] A, int[] B) { List<SimpleEntry<Integer, Integer>> B_sorted = new ArrayList<>(); for (int i = 0; i < B.length; i++) { B_sorted.add(new SimpleEntry<>(B[i], i)); } B_sorted.sort(Comparator.comparingInt(SimpleEntry::getKey)); int j = 0; // Initialize right pointer int[] res = new int[A.length]; // Initialize the result array
Solution Building: Step 3
Solution Building: Step 4
In this final step, we employ the indices from B_sorted to alter the appropriate elements in array A. Based on the position of the right pointer j, we replace the corresponding element in res with the element in A located at the same index.
import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.Comparator;import java.util.List;import java.util.AbstractMap.SimpleEntry;public class FindAndReplace { public static int[] findAndReplace(int[] A, int[] B) { List<SimpleEntry<Integer, Integer>> B_sorted = new ArrayList<>(); for (int i = 0; i < B.length; i++) { B_sorted.add(new SimpleEntry<>(B[i], i)); } B_sorted.sort(Comparator.comparingInt(SimpleEntry::getKey)); int j = 0; // Initialize right pointer int[] res = new int[A.length]; // Initialize the result array for (int i = 0; i < B.length; i++) { int target = 2 * B_sorted.get(i).getKey(); // The target is twice the current number in the sorted B while (j < B.length - 1 && B_sorted.get(j + 1).getKey() < target) { j++; // Move the right pointer to find a number smaller than or equal to the target } if (j < B.length - 1 && Math.abs(B_sorted.get(j + 1).getKey() - target) < Math.abs(target - B_sorted.get(j).getKey())) { j++; // Move the right pointer one more step if the next number is closer to the target } res[B_sorted.get(i).getValue()] = A[B_sorted.get(j).getValue()]; // Collect the corresponding element from A at the same index as the closest number in B_sorted } return res; } public static void main(String[] args) { int[] A = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110}; int[] B = {4, 12, 3, 9, 6, 1, 5, 8, 37, 25, 100}; int[] result = findAndReplace(A, B); System.out.println(Arrays.toString(result)); }}
And there you have it! You've successfully crafted a Java function capable of producing the required output. This function iteratively replaces each element in array A according to the defined logic and returns the modified array.
Complexity Analysis
Lesson Summary
Great job! You've successfully tackled a high-level task that involved manipulating arrays and implementing advanced techniques such as sorting and the two-pointer method. Through this exercise, you've honed your Java coding skills further and demonstrated your ability to solve a complex, real-world challenge.
Now it's your turn to master these techniques. We encourage you to practice solving similar challenges using the skills you've learned from this lesson. The more you practice, the better your problem-solving skills will become. So, get started and enjoy your journey in coding!
public static int[] findAndReplace(int[] A, int[] B) { List<SimpleEntry<Integer, Integer>> B_sorted = new ArrayList<>(); for (int i = 0; i < B.length; i++) { B_sorted.add(new SimpleEntry<>(B[i], i)); } B_sorted.sort(Comparator.comparingInt(SimpleEntry::getKey)); int j = 0; // Initialize right pointer int[] res = new int[A.length]; // Initialize the result array
The primary logic of the problem lies in this step. We iterate over each item in B_sorted using its index i. For every item, we calculate the target, which is double the value of the element at the current index in B_sorted. We adjust the position of the right pointer, j, until it points to the closest number that is less than the target (2⋅B_sorted.get(i).getKey()). The operation continues as long as j is within the bound for B_sorted and the next number in the array is smaller than the target.
Once we've identified a number greater than or equal to the target, we compare it with the previous number to see which one is closer to the target. If the next number is closer, we advance j by one step.
Java
for (int i = 0; i < B.length; i++) { int target = 2 * B_sorted.get(i).getKey(); // The target is twice the current number in the sorted B while (j < B.length - 1 && B_sorted.get(j + 1).getKey() < target) { j++; // Move the right pointer to find a number smaller than or equal to the target } if (j < B.length - 1 && Math.abs(B_sorted.get(j + 1).getKey() - target) < Math.abs(target - B_sorted.get(j).getKey())) { j++; // Move the right pointer one more step if the next number is closer to the target }
Java
import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.Comparator;import java.util.List;import java.util.AbstractMap.SimpleEntry;public class FindAndReplace { public static int[] findAndReplace(int[] A, int[] B) { List<SimpleEntry<Integer, Integer>> B_sorted = new ArrayList<>(); for (int i = 0; i < B.length; i++) { B_sorted.add(new SimpleEntry<>(B[i], i)); } B_sorted.sort(Comparator.comparingInt(SimpleEntry::getKey)); int j = 0; // Initialize right pointer int[] res = new int[A.length]; // Initialize the result array for (int i = 0; i < B.length; i++) { int target = 2 * B_sorted.get(i).getKey(); // The target is twice the current number in the sorted B while (j < B.length - 1 && B_sorted.get(j + 1).getKey() < target) { j++; // Move the right pointer to find a number smaller than or equal to the target } if (j < B.length - 1 && Math.abs(B_sorted.get(j + 1).getKey() - target) < Math.abs(target - B_sorted.get(j).getKey())) { j++; // Move the right pointer one more step if the next number is closer to the target } res[B_sorted.get(i).getValue()] = A[B_sorted.get(j).getValue()]; // Collect the corresponding element from A at the same index as the closest number in B_sorted } return res; } public static void main(String[] args) { int[] A = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110}; int[] B = {4, 12, 3, 9, 6, 1, 5, 8, 37, 25, 100}; int[] result = findAndReplace(A, B); System.out.println(Arrays.toString(result)); }}
It's vital to have an understanding of the computational complexity of our Two-Pointer approach and why it's effective for this problem.
Time Complexity: The main steps of our solution involve sorting the array B and traversing it with two pointers. Sorting an array of n elements has a time complexity of O(nlogn). The two-pointer traversal of the sorted array adds an O(n) time complexity. Thus, the overall time complexity of our solution is O(nlogn) for the sorting operation, which dominates the linear time traversal.
Space Complexity: Apart from the input data, our solution needs space for B_sorted and res, both of which are arrays having the same length as the input. Therefore, our solution has a linear space complexity of O(n), where n is the length of the input arrays.
