Minimum Right Shifts to Sort the Array - Practice Coding Problems

Minimum Right Shifts to Sort the Array - Problem

Array Easy

Transform an array into sorted order using right shifts!

Imagine you have an array of distinct positive integers that needs to be sorted, but you can only perform one type of operation: right shifts. In a right shift, every element moves one position to the right, and the last element wraps around to the front.

Your goal is to find the minimum number of right shifts needed to sort the array in ascending order. If it's impossible to sort the array using only right shifts, return -1.

Key insight: An array can be sorted using right shifts if and only if it's a rotation of a sorted array. For example, [3, 4, 5, 1, 2] is a rotation of [1, 2, 3, 4, 5].

Example: [3, 4, 5, 1, 2] → [2, 3, 4, 5, 1] → [1, 2, 3, 4, 5] (2 right shifts)

Input & Output

example_1.py — Basic Rotation

$ Input: nums = [3, 4, 5, 1, 2]

› Output: 2

💡 Note: The array needs 2 right shifts to become sorted. After 1 right shift: [2, 3, 4, 5, 1]. After 2 right shifts: [1, 2, 3, 4, 5] which is sorted.

example_2.py — Already Sorted

$ Input: nums = [1, 2, 3, 4, 5]

› Output: 0

💡 Note: The array is already sorted in ascending order, so no right shifts are needed.

example_3.py — Impossible Case

$ Input: nums = [2, 1, 4, 3]

› Output: -1

💡 Note: This array cannot be sorted using only right shifts because it has multiple break points (2>1 and 4>3), indicating it's not a rotation of a sorted array.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
All integers in nums are distinct
The array contains only positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

A sortable rotated array has exactly one 'cliff' where a large number drops to a smaller one

Find the Break Point

Scan the array to find where nums[i] > nums[i+1] - this is our rotation point

Validate Rotation

Check that the last element can connect back to the first (last ≤ first)

Calculate Shifts

The number of right shifts needed is n - (break_position + 1)

Key Takeaway

🎯 Key Insight: A rotated sorted array has exactly one position where the sequence 'breaks' - finding this break point allows us to calculate the minimum shifts needed in O(n) time.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses the key insight that a rotated sorted array has exactly one break point where a larger element is followed by a smaller element. By finding this break point in O(n) time, we can calculate the required shifts as n - (break_index + 1). If there are zero break points, the array is already sorted. If there are multiple break points, it's impossible to sort with rotations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Rotations)	O(n²)	O(1)	Try all possible right shifts (0 to n-1) and check if any results in a sorted array
Single Pass Rotation Point Detection (Optimal)	O(n)	O(1)	Find the rotation point by counting order violations in a single pass

Brute Force (Try All Rotations) — Algorithm Steps

For each possible number of shifts k from 0 to n-1:
Create a rotated version of the array with k right shifts
Check if this rotated array is sorted in ascending order
If sorted, return k as the minimum number of shifts
If no rotation produces a sorted array, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with the given array [3,4,5,1,2]

0 Right Shifts

Check [3,4,5,1,2] - not sorted (5>1 violation)

1 Right Shift

Check [2,3,4,5,1] - not sorted (5>1 violation)

2 Right Shifts

Check [1,2,3,4,5] - sorted! Return 2

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int isSorted(int* arr, int n) {
    for (int i = 1; i < n; i++) {
        if (arr[i] < arr[i-1]) {
            return 0;
        }
    }
    return 1;
}

int minimumRightShifts(int* nums, int n) {
    int* rotated = (int*)malloc(n * sizeof(int));
    
    // Try all possible right shifts
    for (int shifts = 0; shifts < n; shifts++) {
        // Create rotated array
        for (int i = 0; i < n; i++) {
            rotated[i] = nums[(i - shifts + n) % n];
        }
        
        if (isSorted(rotated, n)) {
            free(rotated);
            return shifts;
        }
    }
    
    free(rotated);
    return -1;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100];
    int n = 0;
    
    char* token = strtok(input, "[],");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%d\n", minimumRightShifts(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We try n different rotations, and for each rotation, we check if the array is sorted in O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current rotation and check sortedness

✓ Linear Space

18.9K Views

Medium Frequency

~15 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Rotations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler