Smallest Rotation with Highest Score

Smallest Rotation with Highest Score - Problem

You are given an array nums. You can rotate it by a non-negative integer k so that the array becomes [nums[k], nums[k + 1], ... nums[nums.length - 1], nums[0], nums[1], ..., nums[k-1]].

Afterward, any entries that are less than or equal to their index are worth one point.

For example, if we have nums = [2,4,1,3,0], and we rotate by k = 2, it becomes [1,3,0,2,4]. This is worth 3 points because:

1 > 0 [no points]
3 > 1 [no points]
0 ≤ 2 [one point]
2 ≤ 3 [one point]
4 ≤ 4 [one point]

Return the rotation index k that corresponds to the highest score we can achieve if we rotated nums by it. If there are multiple answers, return the smallest such index k.

Input & Output

Example 1 — Basic Rotation

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

› Output: 3

💡 Note: Rotating by k=3 gives [3,0,2,4,1]. Score: 3>0 (no), 0≤1 (yes), 2≤2 (yes), 4>3 (no), 1≤4 (yes) = 3 points. This is optimal.

Example 2 — Multiple Optimal Solutions

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

› Output: 0

💡 Note: No rotation needed. Score: 1>0 (no), 3>1 (no), 0≤2 (yes), 2≤3 (yes), 4≤4 (yes) = 3 points. This equals other rotations but k=0 is smallest.

Example 3 — Edge Case Small Array

$ Input: nums = [1,1]

› Output: 1

💡 Note: k=0: [1,1] scores 1 point (1≤1). k=1: [1,1] scores 1 point (1≤1). Both equal, return k=1 since it's the only other option.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] < nums.length

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is to avoid recalculating scores for each rotation by tracking when elements contribute points. The difference array approach efficiently computes all rotation scores in O(n) time by marking score changes. Best approach uses difference array: Time O(n), Space O(n).

Common Approaches

✓ Brute Force - Try All Rotations

⏱️ Time: O(n²) Space: O(1)

For each possible rotation k from 0 to n-1, rotate the array and count how many elements satisfy nums[i] ≤ i condition. Keep track of the maximum score and smallest k that achieves it.

Optimized with Difference Array

⏱️ Time: O(n) Space: O(n)

Instead of recalculating scores for each rotation, we analyze when each element contributes or stops contributing points as k increases. We use a difference array to efficiently compute all scores.

Brute Force - Try All Rotations — Algorithm Steps

For each k from 0 to n-1:
Rotate array by k positions
Count elements where nums[i] ≤ i
Track maximum score and corresponding k

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with nums = [2,4,1,3,0]

Try Each k

For k=0,1,2,3,4 calculate score

Find Best

Return k with highest score

Code -

solution.c — C

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

static int nums[100005];

int solution(int n) {
    int maxScore = -1;
    int bestK = 0;
    
    for (int k = 0; k < n; k++) {
        int score = 0;
        for (int i = 0; i < n; i++) {
            // After rotation by k, element at position i comes from original index (i + k) % n
            if (nums[(i + k) % n] <= i) {
                score++;
            }
        }
        
        if (score > maxScore) {
            maxScore = score;
            bestK = k;
        }
    }
    
    return bestK;
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    const char* p = line;
    
    // Skip '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        char* endptr;
        long val = strtol(p, &endptr, 10);
        nums[n++] = (int)val;
        p = endptr;
    }
    
    int result = solution(n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Outer loop runs n times, inner loop processes n elements for each rotation

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track current best result, no extra data structures

✓ Linear Space

28.5K Views

Medium Frequency

~35 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