Rank Teams by Votes - Practice Coding Problems

Rank Teams by Votes - Problem

Election Committee Challenge: Rank Teams by Votes

Imagine you're running a democratic voting system for a programming competition! 🗳️ Each voter ranks ALL participating teams from their most favorite (position 1) to least favorite (last position).

Here's how the special ranking algorithm works:
1. Primary Sort: Count position-1 votes - team with most first-place votes wins
2. Tie Breaking: If teams tie for first-place votes, compare their second-place votes, then third-place, and so on
3. Final Tie Breaker: If still tied after all positions, sort alphabetically by team letter

Input: Array of vote strings where each string represents one voter's complete ranking
Output: Single string of team letters sorted by the ranking algorithm

Example: If votes are ["ABC", "ACB", "ABC"]:
- Team A: 3 first-place votes → Winner!
- Team B: 2 second-place, 1 third-place
- Team C: 1 second-place, 2 third-place
Result: "ABC"

Input & Output

example_1.py — Basic Ranking

$ Input: votes = ["ABC", "ACB", "ABC"]

› Output: "ABC"

💡 Note: Team A gets 3 first-place votes and wins. For second place, B gets 2 second-place votes vs C's 1, so B beats C.

example_2.py — Tie Breaking

$ Input: votes = ["WXYZ", "XYZW", "YZWX", "ZWXY"]

› Output: "XWYZ"

💡 Note: All teams tie with 1 first-place vote each. Check second-place: W=1, X=1, Y=1, Z=1 (still tied). Continue checking until differences emerge, then use alphabetical order.

example_3.py — Single Voter

$ Input: votes = ["ZMNAGUEDSJYLBOPHRQICWFXTVK"]

› Output: "ZMNAGUEDSJYLBOPHRQICWFXTVK"

💡 Note: With only one voter, the result is simply that voter's preference order since there are no ties to break.

Constraints

1 ≤ votes.length ≤ 1000
1 ≤ votes[i].length ≤ 26
votes[i].length == votes[j].length for all i, j
votes[i][j] is an English uppercase letter
All characters of votes[i] are unique
All the characters that occur in votes[0] also occur in votes[j] where 1 ≤ j < votes.length

Visualization

Tap to expand

Understanding the Visualization

Collect Ballots

Each voter submits a complete ranking of all teams

Tally Votes

Count how many votes each team got at each position

Apply Rules

Sort by 1st place votes, then 2nd place, then 3rd, etc.

Break Ties

Use alphabetical order if teams are still tied after all positions

Key Takeaway

🎯 Key Insight: This is essentially lexicographic sorting on multi-dimensional vectors where each team's vote counts form a vector [pos1_votes, pos2_votes, ...], and we sort by comparing these vectors position by position with alphabetical names as the final tiebreaker.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a hash table to count votes in O(v×m) time, then sorts teams with a custom comparator in O(n×log n×m) time. The key insight is treating each team's vote counts as a multi-dimensional vector and sorting lexicographically by position priority, with alphabetical order as the final tiebreaker.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Manual Comparison)	O(n² × m)	O(n × m)	Compare every pair of teams manually by checking vote positions one by one
Hash Table + Custom Sorting (Optimal)	O(v × m + n × log n × m)	O(n × m)	Count all votes in one pass, then sort teams using custom comparator

Brute Force (Manual Comparison) — Algorithm Steps

Get all unique teams from the votes
Count votes for each team at each position
For each pair of teams, compare position by position
Use comparison results to manually sort the teams
Handle alphabetical tie-breaking as the final step

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Votes

Build vote count matrix for each team at each position

Compare Pairs

Compare every pair of teams position by position

Bubble Sort

Use comparison results to bubble sort teams

Code -

solution.c — C

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

char* rankTeams(char** votes, int votesSize, int* returnSize) {
    if (votesSize == 0 || !votes[0]) {
        *returnSize = 0;
        return NULL;
    }
    
    int nTeams = strlen(votes[0]);
    char teams[26];
    int teamCount = 0;
    int voteCount[26][26];
    
    // Initialize vote counts
    memset(voteCount, 0, sizeof(voteCount));
    
    // Get unique teams
    int seen[26] = {0};
    for (int i = 0; i < nTeams; i++) {
        if (!seen[votes[0][i] - 'A']) {
            teams[teamCount++] = votes[0][i];
            seen[votes[0][i] - 'A'] = 1;
        }
    }
    
    // Count votes
    for (int i = 0; i < votesSize; i++) {
        for (int j = 0; j < strlen(votes[i]); j++) {
            voteCount[votes[i][j] - 'A'][j]++;
        }
    }
    
    // Brute force bubble sort
    for (int i = 0; i < teamCount; i++) {
        for (int j = i + 1; j < teamCount; j++) {
            int better = 0;
            for (int k = 0; k < nTeams; k++) {
                if (voteCount[teams[i] - 'A'][k] != voteCount[teams[j] - 'A'][k]) {
                    better = voteCount[teams[i] - 'A'][k] > voteCount[teams[j] - 'A'][k];
                    break;
                }
            }
            if (!better && teams[i] >= teams[j]) {
                better = 0;
            } else if (voteCount[teams[i] - 'A'][0] == voteCount[teams[j] - 'A'][0]) {
                better = teams[i] < teams[j];
            }
            
            if (!better) {
                char temp = teams[i];
                teams[i] = teams[j];
                teams[j] = temp;
            }
        }
    }
    
    char* result = (char*)malloc((teamCount + 1) * sizeof(char));
    for (int i = 0; i < teamCount; i++) {
        result[i] = teams[i];
    }
    result[teamCount] = '\0';
    *returnSize = teamCount;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n teams compared pairwise, m positions to check per comparison

⚠ Quadratic Growth

Space Complexity

O(n × m)

Storage for vote counts matrix of n teams × m positions

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~18 min Avg. Time

780 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

Brute Force (Manual Comparison) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler