Simple Java, Beats 100%
ApproachJust compare start track number(rounds[0]) with end track number(rounds[rounds.length - 1]).
If start is less than end, simply add all the numbers from
# Approach
Just compare start track number(rounds[0]) with end track number(rounds[rounds.length - 1]). 
If start is less than end, simply add all the numbers from start to end.

else add numbers from 1 to end, and start to n into the list.
return the list;

The analysis is : Player will start his rounds from rounds[0] and finish at rounds[len - 1], that means, all the tracks would be visited between this range, this cycle can be repeated multiple times. 
But maximum count would be lying within this range.
# Complexity
- Time complexity: O(n), here n is not the length of rounds array. [n is track counts]

- Space complexity: O(1)

# Code
```java []
class Solution {
    public List<Integer> mostVisited(int n, int[] rounds) {
        List<Integer> res = new ArrayList<>();
        int len = rounds.length;
        if(rounds[0] == rounds[len - 1]){
            res.add(rounds[0]);
            return res;
        }

        int start = rounds[0];
        int end = rounds[len - 1];
        if(end < start){
            int t = 1;
            while(t <= end){
                res.add(t);
                t++;
            }
            t = start;
            while(t <= n){
                res.add(t);
                t++;
            }
        }else{
            int t = start;
            while(t <= end){
                res.add(t);
                t++;
            }
        }
        return res;
    }
}
```
['Java']