Maximum Number of Matching Indices After Right Shifts

Maximum Number of Matching Indices After Right Shifts - Problem

You're given two integer arrays nums1 and nums2 of equal length. Your mission is to find the maximum number of indices where elements match after performing any number of right shifts on nums1.

An index i is considered matching when nums1[i] == nums2[i]. A right shift moves every element one position to the right, with the last element wrapping around to the first position.

Example: Array [1,2,3,4] becomes [4,1,2,3] after one right shift.

Your goal is to determine the optimal number of right shifts that maximizes the count of matching indices between the two arrays.

Input & Output

example_1.py — Basic Rotation

$ Input: nums1 = [1,2,3,4], nums2 = [2,3,4,1]

› Output: 4

💡 Note: After 1 right shift, nums1 becomes [4,1,2,3]. After 2 right shifts, nums1 becomes [3,4,1,2]. After 3 right shifts, nums1 becomes [2,3,4,1], which perfectly matches nums2, giving us 4 matching indices.

example_2.py — Partial Match

$ Input: nums1 = [1,2,3], nums2 = [3,1,2]

› Output: 3

💡 Note: After 2 right shifts, nums1 becomes [2,3,1]. After 1 right shift, nums1 becomes [3,1,2], which exactly matches nums2 at all positions.

example_3.py — No Perfect Match

$ Input: nums1 = [1,1,1], nums2 = [1,2,3]

› Output: 1

💡 Note: No matter how we rotate nums1 (all elements are 1), we can only match one position with nums2 at index 0. The maximum number of matches is 1.

Constraints

1 ≤ nums1.length == nums2.length ≤ 1000
1 ≤ nums1[i], nums2[i] ≤ 10⁹
Both arrays have the same length

Visualization

Tap to expand

Understanding the Visualization

Initial Position

Both arrays start in their original positions

Try Rotations

Rotate nums1 by 0, 1, 2... n-1 positions

Count Matches

For each rotation, count how many positions have equal values

Find Maximum

Return the highest match count found across all rotations

Key Takeaway

🎯 Key Insight: Since there are only n possible rotations, we can afford to test them all. The mathematical approach using `(i - shift + n) % n` elegantly simulates rotations without array manipulation.

Asked in

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

The optimal approach tests all n possible rotations using mathematical index calculation (i - shift + n) % n to avoid creating new arrays. While the time complexity remains O(n²), this is optimal since we must check all rotations. The key insight is using modular arithmetic to simulate rotations efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Simulation (Index Math)	O(n²)	O(1)	Use mathematical index calculation to avoid creating rotated arrays
Brute Force (Try All Rotations)	O(n²)	O(n)	Test all possible right shifts (0 to n-1) and count matches for each

Optimized Simulation (Index Math) — Algorithm Steps

Initialize maxMatches to 0
For each possible shift amount (0 to n-1):
For each position i in the array:
Calculate what index in original nums1 would be at position i after rotation
Use formula: rotatedIndex = (i - shift + n) % n
Compare nums1[rotatedIndex] with nums2[i]
Count matches and update maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Position

Element at index i in original array

After Right Shift

Element moves to position (i + shift) % n

Reverse Calculation

To find what's at position i after shift: (i - shift + n) % n

Compare Values

Compare nums1[calculated_index] with nums2[i]

Code -

solution.c — C

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

int maxMatchingIndices(int* nums1, int* nums2, int n) {
    int maxMatches = 0;
    
    // Try all possible right shifts (0 to n-1)
    for (int shift = 0; shift < n; shift++) {
        int matches = 0;
        
        // Use index math instead of creating rotated array
        for (int i = 0; i < n; i++) {
            // Calculate which original index would be at position i after shift
            int rotatedIndex = (i - shift + n) % n;
            if (nums1[rotatedIndex] == nums2[i]) {
                matches++;
            }
        }
        
        if (matches > maxMatches) {
            maxMatches = matches;
        }
    }
    
    return maxMatches;
}

int main() {
    int nums1[] = {1, 2, 3, 4};
    int nums2[] = {2, 3, 4, 1};
    int n = 4;
    printf("%d\n", maxMatchingIndices(nums1, nums2, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Still need to test n rotations and count n elements for each

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

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

Optimized Simulation (Index Math) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler