The best way to sort the list by reversing the sublist

Question

Now I recently saw this question (I can’t remember exactly where) about how few operations were needed to sort the list of numbers, excluding the reversal of the sublist.

Here is an example:
Unsorted input :3, 1, 2, 5, 4

One possible answer:
1. The inverse index from 0 to 3, giving 5, 2, 1, 3, 4
2. The inverse index from 0 to 4, giving 4, 3, 1, 2, 5
3. The inverse index from 0 to 3, giving 2, 1, 3, 4, 5
4. The inverse index from 0 to 1, giving1, 2, 3, 4, 5

However, having tried my hand on this problem, it turned out that for those who have not experienced the algorithms, it is really difficult to create a piece of code that finds the best solution. The answer noted above was simply accomplished by crudely forcing all possible combinations, but it becomes unbearably slow when lists are longer than 10 numbers (10 takes <2s, 14 took more than 10 minutes). Installing any existing sorting algorithms does not work either because they were created only to replace individual elements at a time (and replacing 2 numbers by reversing the sublist will take 1-2 operations that are not optimal). I also tried sorting the networks, because the maximum size was already determined before the program started, but I was also unlucky with them (they also rely on swap, which is inefficient,when you have the opportunity to change several at a time). I also tried to make a function that “optimized” the list of operations, like trying to make existing sorting algorithms viable, but these answers were much longer than the optimal ones (think about 16 vs. 6).

, , , . , , "", , - . , , - , , StackOverflow.

, 0 100 ( ). - - 3 < N < 15, , , , .

Answer 1

, .

"" , , .

, , n-1 n: no "" n-1, n-1.

:

• (1, 2, 3,...)
• ,
• ( n-1)
• ()

, ( ), n² , 1 (, , ), .

, , "" .

3 < N < 15, , , .

Answer 2

:

• 0 2: 2 1 3 5 4
• 0 1:1 2 3 5 4
• 3 4: 1 2 3 4 5

, @greybeard - . , - , + , - "".

, , " " , ( , ) , .

, , , , .

,

Answer 3

, ( ). , . , , , .

. [3 4 5 1 2] : [3 4 5] [1 2]. , 4 . [1 5 4 3 2]. , 4 ( [5 4 3 2]).

, , , , () . ( .)

:

[3 1 2 5 4] ( 2) → [3 4 5 2 1] ( 3) → [5 4 3 2 1] ( 5) → [1 2 3 4 5] ( 5, ).

, OP . O(n^3) , O(n^2) .

, , - , . , "6" , , 4 [4 5 6], . , , , , . , , , .

Answer 4

, :

• , . .
• 2- (3-, 4- ..), , .

1), , java [3, 1, 2, 5, 4]:

private static int[] reverseSort(int[] array) {
        int temp;
        int count = 0;
        boolean reversed = false;
        do {
            reversed = false;
            for (int i = 0; i < array.length-1; i++) {
                if (array[i] > array[i+1]) {
                    temp = array[i];
                    array[i] = array[i+1];
                    array[i+1] = temp;
                    count++;
                    System.out.println(count + ": reverse [" + i + ", " + (i + 1) + "]");
                    reversed = true;
                }
            }
        } while (reversed);
        return array;
    }

() :

1: reverse [0, 1]
2: reverse [1, 2]
3: reverse [3, 4]

, 2-! ( ).

2), - , . , ...

Hint (which was requested) regarding the recipe: for 3 tuples, go through each consecutive set of 3 tuples to see if they are associated with the 3 tuple. So, for example, the switches [1,2] [2,3] [1,2] and [2,3] [1,2] [2,3] will generate [1, 2, 3] from [3, 2 , 1] and can be replaced by a reverse connection. Summarize the n-tuple and stop when n = the length of the array.