Rank the Top Two Competition Teams

Four aligned arrays describe each team. Team i earns 3 * wins[i] + draws[i] points and has difference scored[i] - conceded[i].
Rank teams by points descending, then difference descending, then index ascending. Return the indices of the top two teams.

Function
topTwoTeams(wins: int[], draws: int[], scored: int[], conceded: int[]) → int[]

Examples
Example 1
wins = [3,2,1]
draws = [0,2,5]
scored = [5,5,5]
conceded = [1,1,1]
return = [0,1]
The primary point totals determine the top two.
Example 2
wins = [2,2,1]
draws = [0,0,3]
scored = [10,7,9]
conceded = [4,4,4]
return = [0,2]
Equal points are ordered by larger scored-minus-conceded difference.

Constraints
2 <= wins.length <= 100000
All four arrays have equal length and contain values from 0 through 100000.

The trick is that you don't need a full sort. Build a key per team, then either sort all n teams in O(n log n) or scan once, tracking the best two in O(n). Both pass at 100000 teams. The clean version is a sort with the key (-points, -diff, index). Negating the first two fields gives descending order while index stays ascending, so ties resolve for free. The common pitfall is comparing only points and forgetting the difference tiebreak, which fails Example 2 where teams 0 and 1 tie on 6 points. Another is returning points or sorted values instead of original indices. Keep the index attached to each record before sorting. Values stay small, so overflow isn't a concern, and difference can be negative, so don't assume it's nonnegative. If your mind goes blank on the comparator mid-assessment, StealthCoder can surface the tuple-key sort so you just type it out.

Memorize the pattern. If you can't, run StealthCoder. The proctor sees the IDE. They don't see what's behind it.