Algorithm to sort an Array, in which every element is 10 positions away from where it should be

Question

What is the most efficient sorting algorithm to sort an Array, that has n elements and EVERY element originally is 10 position away from its position after sorting?

I am thinking about insertion sort, but I have no clue how to proof that:

(1) It is the most efficient.

(2) The algorithm needs in worst case O(n) steps to sort the Array.

A self-conceived example: [10,11,12,13,14,15,16,17,18,19,0,1,2,3,4,5,6,7,8,9,]

Give examples. When you say 10 positions away, I think we can safely say it's original position is +10 or -10 from the current position. — nice_dev, Jun 08 '21 at 15:36
yes exactly the original position is +- 10 from its current position — El magnifico, Jun 08 '21 at 15:37
sadly i have no good examples but maybe this could be an example : — El magnifico, Jun 08 '21 at 15:40
With insertion sort, you will need a maximum of 10 shifts to move an element into its final place. That is O(n). — rossum, Jun 08 '21 at 15:45
That example seems wrong: 20 is nine positions away from its target, and 1 is eleven positions away from its target. Does distance also work "wrapping around" the array boundaries? — trincot, Jun 08 '21 at 16:59
The question would make more sense if each record is _at most_ 10 positions away. — Henry, Jun 09 '21 at 04:55

trincot · Answer 1 · 2021-06-09T06:39:25.483

With these constraints there are not that many possibilities:

The value at index 0 must go to index 10 as that is the only index that is 10 positions away from index 0. And which value can move to index 0? It can only be the value that is currently at index 10. So it's a swap between indexes 0 and 10.

With the same reasoning the value at index 1 will swap with the value at index 11, and 2 with 12, 3 with 13, ... 9 with 19.

So now we have covered all indices in the range 0..19. No values outside this range will get into this range, nor will any value in this range move out of it. All movements involving these indices are already defined above.

We can repeat the same reasoning for indices in the range 20..39, and again from positions 40..59, ...etc

So we can conclude:

The array's size is necessarily a multiple of 20
Only one permutation is possible that abides to the given rules
The solution is therefore simple.

Solution in pseudo code:

sort(A):
    for i = 0 to size(A) - 1 step 20:
        swap A[i+0..i+9] with A[i+10..i+19]

In some languages the swap of such array slices can be done very efficiently.

This is correct if all of the elements are distinct; I'm not sure the question makes sense otherwise ("its position" implies each element has only one possible position once the array is sorted) but maybe worth noting this assumption. — kaya3, Jun 09 '21 at 07:36

score 0 · Answer 2 · answered Jun 08 '21 at 16:12

When you say 10 positions away, the actual position could be i - 10 or i + 10. So, just make a temporary copy of the array and take minimums for each 10 index positions away.

This is because the only clash we can assume is some index going for +10 and another index going for -10 for some same index j. So taking minimums will install correct value at the index j.

private static void solve(int[] arr){
        int[] temp = new int[arr.length];
        Arrays.fill(temp,Integer.MAX_VALUE);
        for(int i=0;i<arr.length;++i){
            if(i - 10 >= 0) temp[i - 10] = Math.min(temp[i - 10],arr[i]);
            if(i + 10 < temp.length) temp[i + 10] = Math.min(temp[i + 10],arr[i]);
        }
        
        for(int i=0;i<arr.length;++i) arr[i] = temp[i];
 }

Algorithm to sort an Array, in which every element is 10 positions away from where it should be

2 Answers2