# Solving Leetcode Interviews in Seconds with AI: Smallest Rotation with Highest Score


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "798" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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.   Example 1:  Input: nums = [2,3,1,4,0] Output: 3 Explanation: Scores for each k are listed below:  k = 0,  nums = [2,3,1,4,0],    score 2 k = 1,  nums = [3,1,4,0,2],    score 3 k = 2,  nums = [1,4,0,2,3],    score 3 k = 3,  nums = [4,0,2,3,1],    score 4 k = 4,  nums = [0,2,3,1,4],    score 3 So we should choose k = 3, which has the highest score.  Example 2:  Input: nums = [1,3,0,2,4] Output: 0 Explanation: nums will always have 3 points no matter how it shifts. So we will choose the smallest k, which is 0.    Constraints:  1 <= nums.length <= 105 0 <= nums[i] < nums.length  

	# Explanation
	Here's the solution:

*   **Difference Array:** The core idea is to use a difference array to efficiently track how the score changes with each rotation. For each element `nums[i]`, we determine the range of rotations where it contributes to the score. This range is then used to update the difference array.
*   **Cumulative Sum:** After calculating the difference array, we compute its cumulative sum. This cumulative sum array represents the score for each possible rotation `k`.
*   **Find Maximum:** Finally, we iterate through the cumulative sum array to find the maximum score and its corresponding rotation index `k`. We return the smallest such index in case of ties.

*   **Runtime Complexity:** O(n), **Storage Complexity:** O(n)

	
	# Code
	```python
	def bestRotation(nums):
    n = len(nums)
    diffs = [0] * n
    for i in range(n):
        low = (i + 1) % n
        high = (i - nums[i] + n) % n
        if low <= high:
            diffs[low] += 1
            if high + 1 < n:
                diffs[high + 1] -= 1
        else:
            diffs[0] += 1
            diffs[high + 1] -= 1
            diffs[low] += 1

    score = 0
    max_score = 0
    best_rotation = 0
    for i in range(n):
        score += diffs[i]
        if score > max_score:
            max_score = score
            best_rotation = i

    return best_rotation
	```