Rank Teams by Votes — Editorial

Opening the reading…

Intuitionthe ranking rule is a lexicographic comparison in disguise

The rule compares teams at first place before it considers second place, and second place before it considers third place. For each team, record a count for every position: its first-place count, its second-place count, and so on. This produces one count vector per team, and the overall ranking compares these vectors from left to right.

When two vectors first differ, the team with the larger count at that position wins, because every later position is irrelevant once an earlier position breaks the tie. If the vectors never differ, the teams are genuinely tied by votes, so comparing their letters alphabetically gives a deterministic final order.

Approachturn each ranking into one row of position counts

Read the number of voters n and the number of teams m from the input, because every vote has the same length and each position needs its own count.

Create cnt[team][position], initially zero, with one row for each uppercase letter and m columns, so votes for different positions cannot be mixed together.

For every vote and every position i, increment the count for that vote's team at position i. Without this step, the comparator would have no information about how teams performed across the ballots.

Start with the team letters from votes[0], because the statement guarantees that this contains every team exactly once and excludes letters that are not part of the contest.

Sort those letters with a comparator that scans positions from 0 through m - 1 and puts the team with the larger count first at the first position where the counts differ.

If all position counts match, compare the letters directly so tied teams appear in alphabetical order rather than depending on the sort's unspecified tie arrangement.

Return the sorted string, which already contains every team exactly once and therefore is the required ranking.

Complexitycounting is linear in the ballots; comparison can inspect every position

MEASURE	BOUND	WHY
Time	O(nm + m^2 log m)	Building the count table visits each of the n votes at all m positions. Sorting performs O(m log m) comparisons, and one comparison may scan all m positions before finding a difference, so the worst case is O(m^2 log m) for sorting.
Space	O(26m) extra, or O(m) with the fixed alphabet	The count table has 26 rows and m columns, while sorting the m-character string uses only the sort routine's small auxiliary stack. The returned string is required output and is excluded. This bound does not degrade with the arrangement of the votes; even the worst tie pattern only makes comparisons scan farther, not the count table grow.

Here n is the number of votes and m is the number of teams, which is also the length of each vote. The alphabet has a fixed size of 26.

Annotated solutionC++ · count table plus a lexicographic custom comparator

CPPCount each team by position, then sort the team letters with the ranking rule.

#include <algorithm>
#include <string>
#include <vector>

using namespace std;

class Solution {
public:
    string rankTeams(vector<string>& votes) {
        if (votes.empty()) return "";

        int n = votes.size();
        int m = votes[0].size();
        vector<vector<int>> cnt(26, vector<int>(m, 0));

        for (const string& vote : votes) {
            for (int i = 0; i < m; ++i) {
                cnt[vote[i] - 'A'][i]++;
            }
        }

        string teams = votes[0];
        sort(teams.begin(), teams.end(), [&](char a, char b) {
            int ia = a - 'A';
            int ib = b - 'A';

            for (int i = 0; i < m; ++i) {
                if (cnt[ia][i] != cnt[ib][i]) {
                    return cnt[ia][i] > cnt[ib][i];
                }
            }

            return a < b;
        });

        return teams;
    }
};

The comparator must scan positions in voting order, not in whichever order is convenient. Returning as soon as one count differs is safe because that position is the first evidence separating the teams. The final a < b comparison is reached only when every count matches, so it implements the problem's alphabetical tie-break without overriding any meaningful vote result.