Check if Array Is Sorted and Rotated - Practice Coding Problems

Check if Array Is Sorted and Rotated - Problem

Array Easy

Imagine you have a perfectly sorted array, but someone rotated it by moving some elements from the front to the back. Your task is to determine if an array could have been created this way!

Given an array nums, return true if the array was originally sorted in non-decreasing order, then rotated some number of positions (including zero). Otherwise, return false.

What does rotation mean? When we rotate an array by x positions, we take the first x elements and move them to the end. For example:

Original: [1, 2, 3, 4, 5]
Rotate by 2: [3, 4, 5, 1, 2]

Note: The original array may contain duplicates, and rotating by 0 positions means the array stays the same.

Input & Output

example_1.py — Basic Rotation

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

› Output: true

💡 Note: The original array was [1,2,3,4,5] rotated 3 times to the right, giving us [3,4,5,1,2].

example_2.py — Invalid Array

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

› Output: false

💡 Note: There's no rotation of a sorted array that would give us [2,1,3,4]. This has 2 break points: 2>1 and 4>2 (circular).

example_3.py — Already Sorted

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

› Output: true

💡 Note: The array is already sorted (rotation by 0), so it's a valid rotated sorted array.

Constraints

1 ≤ nums.length ≤ 100
-10⁴ ≤ nums[i] ≤ 10⁴
The array may contain duplicates

Visualization

Tap to expand

Understanding the Visualization

Original Sorted Array

Start with [1,2,3,4,5] - perfectly sorted with no breaks

Apply Rotation

Rotate by 3 positions → [3,4,5,1,2] creates one break at 5→1

Count Break Points

Scan array: 3≤4✓, 4≤5✓, 5>1✗, 1≤2✓, 2≤3✓ = 1 break total

Validation

Since break count = 1 ≤ 1, this is a valid rotated sorted array

Key Takeaway

🎯 Key Insight: A sorted array rotated by any amount will have exactly one position where the order 'breaks' (larger number followed by smaller). Count these breaks in O(n) time!

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses the key insight that a sorted rotated array has at most one break point where nums[i] > nums[i+1]. Count these breaks in O(n) time and O(1) space - if count ≤ 1, return true.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Break Count (Optimal)	O(n)	O(1)	Count positions where nums[i] > nums[i+1] - should be at most 1
Brute Force (Try All Rotations)	O(n²)	O(n)	Try every possible rotation point and check if the resulting array is sorted

One-Pass Break Count (Optimal) — Algorithm Steps

Initialize break_count = 0
Iterate through array and count positions where nums[i] > nums[(i+1)%n]
Also check if last element > first element (circular break)
If break_count <= 1, return true; otherwise false

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Break Points

Look for positions where nums[i] > nums[i+1]

Count Breaks

In [3,4,5,1,2], we have one break: 5 > 1

Check Circular

Also check if last > first: 2 < 3, so no additional break

Validate Count

Total breaks = 1 ≤ 1, so return true

Code -

solution.c — C

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

bool check(int* nums, int numsSize) {
    if (numsSize <= 1) return true;
    
    int breakCount = 0;
    
    // Count positions where nums[i] > nums[i+1]
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > nums[(i + 1) % numsSize]) {
            breakCount++;
            if (breakCount > 1) {
                return false;
            }
        }
    }
    
    return true;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    
    scanf("%c", &c); // Read '['
    if (scanf("%d", &nums[0])) {
        size = 1;
        while (scanf("%c", &c) && c != ']') {
            if (c == ',') {
                scanf("%d", &nums[size]);
                size++;
            }
        }
    } else {
        scanf("%c", &c); // Read ']'
    }
    
    printf("%s\n", check(nums, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to count break points

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra variables

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.9K 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

One-Pass Break Count (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler