Speed efficiency in rebuilding an array - arrays

Question

If I have two arrays of ints e.g. [100, 50, 32, 23] and [40, 30, 32, 125] and a number 50 then the numbers in the first array that is greater than this number should be removed along with its corresponding index pair in the 2nd array.
If i did this manually for every element value and rebuilding the int array each time as I go along over 10,000 elements wouldn't this be incredibly inefficient/slow?
input 50:
new array changes:
[50, 32, 23]
[30, 32, 125]
pseudo code so far:
for each value in array one that is greater than input, remove it and rebuild both arrays, continue
Not sure how I can learn where or what direction I should go in finding a more efficient/faster way of doing this.

Answer 1

Here is an O(n) implementation. It goes through the arrays once to find out how many elements will be retained, creates new arrays too hold the result, then copies the integers that should lower or equal to the limit into the new arrays. I assume the two arrays are held together in an int[][] because that is the most efficient way to pass them around.
public static int[][] removeGreaterThan(int[][] arrays, int limit) {
int retained = 0;
for (int i = 0; i < arrays[0].length; i++) {
if (arrays[0][i] <= limit) retained++;
}
int[][] result = new int[][] {new int[retained], new int[retained]};
int j = 0;
for (int i = 0; i < arrays[0].length; i++) {
if (arrays[0][i] <= limit) {
result[0][j] = arrays[0][i];
result[1][j] = arrays[1][i];
j++;
}
}
return result;
}
Use it like this.
int[][] arrays = new int[][] {{100, 50, 32, 23}, {40, 30, 32, 125}};
int[][] result = removeGreaterThan(arrays, 50);
// you can check to make sure the values are correct
System.out.println(Arrays.asList(result[0]);
System.out.println(Arrays.asList(result[1]);

Answer 2

I would create a SortedMap of your 2 arrays and then extract the pairs with a key smaller than or equal to your input parameter:
Suppose your arrays are like this:
int[] array_1;
int[] array_2;
Convert these arrays into a map:
NavigableMap<Integer, Integer> my_map = new TreeMap();
int index;
for (index = 0; index < array_1.length; index++)
my_map.put(array_1[index], array_2[index]);
Now get all pairs with a key value not greater than the one you specify:
NavigableMap<Integer, Integer> result;
result = my_map.headMap(50, true);
Convert result into new arrays:
array_1 = new int[result.size()];
array_2 = new int[array_1.length];
Iterator<Integer> it = result.keySet().iterator();
index = 0;
Integer key;
while (it.hasNext())
{
key = it.next();
array_1[index] = key;
array_2[index] = result.get(key);
index++;
}
Of course, the final result would be sorted. Not sure if that's a problem.
So, your result would be [23, 32, 50] [125, 32, 30].
Furthermore, it supposes that the keys (the elements in the first array) are unique.

Answer 3

One way to improve on your pseudocode is:
for each iteration
find indexes of first array which are greater than the number.
store indexes in a list.
remove all the elements of the first array using index list. // I can tell you more here but you should give it a try.
remove all the elements of the second array.