Rank Teams by Votes - Practice Coding Problems

Rank Teams by Votes - Problem

In a special ranking system, each voter gives a rank from highest to lowest to all teams participating in the competition.

The ordering of teams is decided by who received the most position-one votes. If two or more teams tie in the first position, we consider the second position to resolve the conflict, if they tie again, we continue this process until the ties are resolved. If two or more teams are still tied after considering all positions, we rank them alphabetically based on their team letter.

You are given an array of strings votes which is the votes of all voters in the ranking systems. Sort all teams according to the ranking system described above.

Return a string of all teams sorted by the ranking system.

Input & Output

Example 1 — Basic Voting

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

› Output: ACB

💡 Note: Team A gets 2 first-place votes, C gets 3. C wins first position. For second position: A gets 3 votes, C gets 2, so A is second. B is last. Result: ACB

Example 2 — Tie Breaking

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

› Output: XWYZ

💡 Note: First position tie: W=1, X=1. Check second position: W=0, X=1, so X wins. Third position: Y=1, Z=1, tie broken alphabetically Y

Example 3 — Alphabetical Fallback

$ Input: votes = ["ZMNAGUEDSJYLBOPHRQICWFXTVK"]

› Output: ZMNAGUEDSJYLBOPHRQICWFXTVK

💡 Note: Only one vote, so all teams have same vote count (1) at their respective positions. Result is alphabetically sorted: ABCDEFGHIJKLMNOPQRSTUVWXYZ

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 in votes[i] are unique

Visualization

Tap to expand

Understanding the Visualization

Input Votes

Array of vote strings, each voter ranks all teams

Count by Position

Count votes each team receives at each position

Sort Teams

Sort by position priority, then alphabetically

Key Takeaway

🎯 Key Insight: Count votes by position priority, then sort teams using multi-level comparison (position votes + alphabetical)

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to count votes by position for each team, then sort using position priority and alphabetical order. Best approach is vote counting with custom comparator. Time: O(n×m + t²×m), Space: O(t×m)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Comparison	O(n³ × m)	O(1)	Compare each pair of teams across all positions manually
Vote Counting with Custom Sort	O(n × m + t² × m)	O(t × m)	Count votes by position for each team, then sort with custom comparator

Brute Force Comparison — Algorithm Steps

Step 1: For each pair of teams, compare position by position
Step 2: Count votes manually for each comparison
Step 3: Sort based on comparisons

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Pairs

For each team pair, count votes at each position

Position-by-Position

Compare position 0, then position 1, etc.

Sort Result

Apply comparisons to sort all teams

Code -

solution.c — C

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

char teams[26];
char votes[1000][27];
int vote_count;
int team_count;
int vote_length;

int compareTeams(const void* a, const void* b) {
    char team1 = *(char*)a;
    char team2 = *(char*)b;
    
    for (int pos = 0; pos < vote_length; pos++) {
        int count1 = 0, count2 = 0;
        for (int i = 0; i < vote_count; i++) {
            if (votes[i][pos] == team1) count1++;
            if (votes[i][pos] == team2) count2++;
        }
        if (count1 != count2) {
            return count2 - count1;
        }
    }
    return team1 - team2;
}

char* solution(char** input_votes, int size) {
    if (size == 0) return "";
    
    vote_count = size;
    vote_length = strlen(input_votes[0]);
    
    for (int i = 0; i < size; i++) {
        strcpy(votes[i], input_votes[i]);
    }
    
    int teamSet[26] = {0};
    for (int i = 0; i < vote_length; i++) {
        teamSet[input_votes[0][i] - 'A'] = 1;
    }
    
    team_count = 0;
    for (int i = 0; i < 26; i++) {
        if (teamSet[i]) {
            teams[team_count++] = 'A' + i;
        }
    }
    
    qsort(teams, team_count, sizeof(char), compareTeams);
    
    static char result[27];
    for (int i = 0; i < team_count; i++) {
        result[i] = teams[i];
    }
    result[team_count] = '\0';
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char* input_votes[1000];
    int size = 0;
    
    char* token = strtok(line + 1, ",");
    while (token && size < 1000) {
        while (*token == ' ' || *token == '"') token++;
        int len = strlen(token);
        while (len > 0 && (token[len-1] == ' ' || token[len-1] == '"' || token[len-1] == ']')) {
            token[len-1] = '\0';
            len--;
        }
        input_votes[size] = token;
        size++;
        token = strtok(NULL, ",");
    }
    
    char* result = solution(input_votes, size);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × m)

O(n²) pairs × O(n) voters × O(m) positions for each comparison

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for comparison, no extra data structures

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

982 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 Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler