Most Visited Sector in a Circular Track - Practice Coding Problems

Most Visited Sector in a Circular Track - Problem

Array Simulation Easy

Imagine you're organizing a marathon race on a circular track! The track is divided into n numbered sectors from 1 to n, and runners move in a counter-clockwise direction through ascending sector numbers.

Given an integer n representing the number of sectors and an array rounds containing the marathon route, you need to determine which sectors were visited most frequently during the entire race.

How it works:

The race consists of multiple rounds
Round i starts at sector rounds[i-1] and ends at sector rounds[i]
Runners visit every sector along their path (inclusive of start and end, except we don't double-count the end of one round and start of the next)
The track is circular, so after sector n comes sector 1

Goal: Return an array of the most frequently visited sectors, sorted in ascending order.

Input & Output

example_1.py — Python

$ Input: n = 4, rounds = [1,3,1,2]

› Output: [1,2]

💡 Note: The marathon starts at sector 1, goes to 3 (visiting 1,2,3), then to 1 (visiting 4,1), then to 2 (visiting 2). Total visits: sector 1: 3 times, sector 2: 3 times, sector 3: 1 time, sector 4: 1 time. Sectors 1 and 2 are most visited.

example_2.py — Python

$ Input: n = 2, rounds = [2,1,2,1,2,1,2,1,2]

› Output: [2]

💡 Note: Multiple rounds between sectors 2 and 1. The race starts at 2 and ends at 2, so sector 2 gets one extra visit compared to sector 1.

example_3.py — Python

$ Input: n = 7, rounds = [1,3,5,7]

› Output: [1,2,3,4,5,6,7]

💡 Note: Each round covers large portions of the track. When we analyze the critical path from start (1) to end (7), all sectors are visited equally due to the intermediate complete cycles.

Visualization

Tap to expand

Understanding the Visualization

Complete Rounds Cancel

Any complete lap around the track visits every sector exactly once

Identify Critical Path

Only the partial segments at the beginning and end create imbalance

Handle Circular Logic

The track wraps around, so start > end means path goes through sector 1

Key Takeaway

🎯 Key Insight: Intermediate complete rounds cancel out - only the incomplete first-to-last path determines which sectors are most visited!

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Where m is the number of rounds and n is the track size. In worst case, each round could traverse the entire track

✓ Linear Growth

Space Complexity

O(n)

We need an array to count visits for each of the n sectors

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 10⁴
1 ≤ rounds.length ≤ 10⁵
rounds[i] will be between 1 and n
All rounds form a valid sequence (each round starts where the previous ended)

Asked in

a Amazon 12 G Google 8 ⊞ Microsoft 6 Apple 4

The optimal solution uses a key mathematical insight: intermediate rounds form complete cycles, so only the path from the first start to the last end matters. This reduces the problem from O(n×m) simulation to O(n) direct computation by identifying the critical path segments.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simulation)	O(n × m)	O(n)	Simulate each round step by step, counting visits to each sector
Optimal (Key Insight)	O(n)	O(k)	Only the first and last segments matter - middle rounds form complete cycles

Brute Force (Simulation) — Algorithm Steps

Initialize a counter array for all sectors
For each round, simulate movement from start to end sector
Handle circular wrapping when crossing from sector n to 1
Count each visited sector (avoid double counting)
Find the maximum frequency and return all sectors with that frequency

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counters

Create counter array for all sectors, starting at 0

Process Round 1

Move from start to end sector, incrementing each counter

Process Round 2

Continue from previous end to next end, handling circular wrap

Find Maximum

Identify sectors with highest visit count

Code -

solution.c — C

int* mostVisited(int n, int* rounds, int roundsSize, int* returnSize) {
    // Count visits to each sector
    int* count = (int*)calloc(n + 1, sizeof(int));  // 1-indexed
    
    // Process each round
    for (int i = 0; i < roundsSize - 1; i++) {
        int start = rounds[i];
        int end = rounds[i + 1];
        
        // Simulate movement from start to end
        int current = start;
        while (1) {
            count[current]++;
            if (current == end) break;
            current = current % n + 1;  // Circular increment
        }
    }
    
    // Find maximum frequency
    int maxCount = 0;
    for (int i = 0; i <= n; i++) {
        if (count[i] > maxCount) {
            maxCount = count[i];
        }
    }
    
    // Count sectors with maximum frequency
    int resultCount = 0;
    for (int i = 1; i <= n; i++) {
        if (count[i] == maxCount) {
            resultCount++;
        }
    }
    
    // Build result array
    int* result = (int*)malloc(resultCount * sizeof(int));
    int idx = 0;
    for (int i = 1; i <= n; i++) {
        if (count[i] == maxCount) {
            result[idx++] = i;
        }
    }
    
    *returnSize = resultCount;
    free(count);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Where m is the number of rounds and n is the track size. In worst case, each round could traverse the entire track

✓ Linear Growth

Space Complexity

O(n)

We need an array to count visits for each of the n sectors

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 10⁴
1 ≤ rounds.length ≤ 10⁵
rounds[i] will be between 1 and n
All rounds form a valid sequence (each round starts where the previous ended)

24.5K Views

Medium Frequency

~15 min Avg. Time

856 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Simulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler