Smallest Rotation with Highest Score - Practice Coding Problems

Smallest Rotation with Highest Score - Problem

You are given an array nums and need to find the optimal rotation that maximizes your score!

How rotation works: When you rotate the array by k positions, it becomes [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]

How scoring works: After rotation, you get 1 point for each element where nums[i] ≤ i (value ≤ index)

Goal: Return the smallest rotation index k that gives you the highest possible score.

Example: With nums = [2,4,1,3,0] and rotation k = 2:

Array becomes: [1,3,0,2,4]
Score calculation: 1 > 0 ❌, 3 > 1 ❌, 0 ≤ 2 ✅, 2 ≤ 3 ✅, 4 ≤ 4 ✅
Total score: 3 points

Input & Output

example_1.py — Basic Rotation

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

› Output: 2

💡 Note: Rotation by k=2 gives [1,3,0,2,4] with score 3 (positions 2,3,4 satisfy condition). This is the maximum possible score.

example_2.py — All Elements Large

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

› Output: 0

💡 Note: No rotation needed. At k=0, we get score 3 from positions 2,3,4. This is already optimal.

example_3.py — Single Element

$ Input: nums = [5]

› Output: 0

💡 Note: With only one element, k=0 is the only option. Element 5 > index 0, so score is 0.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] < nums.length
The optimal solution must handle large arrays efficiently

Visualization

Tap to expand

Understanding the Visualization

Analyze Passenger Preferences

Each passenger has a satisfaction threshold - they're happy if seat number ≥ their requirement

Calculate Contribution Ranges

For each passenger, determine which wheel rotations would satisfy them

Track Score Changes

Use differential tracking to see how satisfaction changes with each rotation

Find Optimal Position

The rotation with maximum satisfied passengers wins!

Key Takeaway

🎯 Key Insight: Rather than simulating every rotation, we mathematically analyze when each element contributes to the score and use differential arrays to efficiently compute all rotation scores in linear time.

Asked in

G Google 15 f Meta 8 🍎 Apple 5 ⊞ Microsoft 3

The optimal solution uses a differential array to track score changes efficiently. Instead of recalculating scores for each rotation, we analyze when each element contributes to the score and use accumulated changes to find the maximum in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Rotations)	O(n²)	O(1)	Try every possible rotation k and calculate the score for each
Differential Array (Optimal)	O(n)	O(n)	Use differential array to track score changes efficiently as we rotate

Brute Force (Try All Rotations) — Algorithm Steps

Iterate through all possible rotation values k from 0 to n-1
For each k, create the rotated array
Count elements where rotated[i] ≤ i to get the score
Track the best score and corresponding smallest k
Return the optimal k

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with the original array [2,4,1,3,0]

Try k=0

No rotation: [2,4,1,3,0]. Score = 2 (positions 3,4)

Try k=1

Rotate by 1: [4,1,3,0,2]. Score = 2 (positions 3,4)

Try k=2

Rotate by 2: [1,3,0,2,4]. Score = 3 (positions 2,3,4)

Find Maximum

Continue for all k, return smallest k with max score

Code -

solution.c — C

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

int bestRotation(int* nums, 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++) {
            // Element at original position (i + k) % n is now at position i
            int originalVal = nums[(i + k) % n];
            if (originalVal <= i) {
                score++;
            }
        }
        
        if (score > maxScore) {
            maxScore = score;
            bestK = k;
        }
    }
    
    return bestK;
}

int main() {
    int nums[20000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // Skip '['
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", bestRotation(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We try n different rotations, and for each rotation we scan n elements to calculate the score

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables, not creating the rotated array

✓ Linear Space

23.5K Views

Medium Frequency

~35 min Avg. Time

892 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