Rank Teams by Votes

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: ABCDEFGHIJKLMNOPQRSTUVWXYZ

💡 Note: Only one vote, so all teams have same vote count (1) at their respective positions. Since all teams tie in voting, they are sorted alphabetically: 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

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

✓ Brute Force Comparison

⏱️ Time: O(n³ × m) Space: O(1)

For each pair of teams, manually compare their vote counts at each position from first to last. This requires nested loops to compare all teams against each other.

Vote Counting with Custom Sort

⏱️ Time: O(n × m + t² × m) Space: O(t × m)

First pass counts how many votes each team received at each position. Then use a custom comparator to sort teams based on position priority and alphabetical order.

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>
#include <ctype.h>

char votes[1000][27];
int vote_count;
int vote_length;

int compareTeams(const void* a, const void* b) {
    char team1 = *(char*)a;
    char team2 = *(char*)b;
    
    // Compare position by position
    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) {
            // Higher count wins - Python: return count2 - count1
            return count2 - count1;
        }
    }
    // Alphabetical order - Python: return -1 if team1 < team2 else 1
    return (team1 < team2) ? -1 : 1;
}

char* solution(char** input_votes, int size) {
    if (size == 0) {
        static char empty[1] = "";
        return empty;
    }
    
    vote_count = size;
    vote_length = strlen(input_votes[0]);
    
    // Copy votes to global array
    for (int i = 0; i < size; i++) {
        strcpy(votes[i], input_votes[i]);
    }
    
    // Extract unique teams from first vote
    char teams[27];
    int team_count = 0;
    int seen[26] = {0};
    
    for (int i = 0; i < vote_length; i++) {
        char team = input_votes[0][i];
        if (!seen[team - 'A']) {
            seen[team - 'A'] = 1;
            teams[team_count++] = team;
        }
    }
    teams[team_count] = '\0';
    
    // Sort teams using comparison function
    qsort(teams, team_count, sizeof(char), compareTeams);
    
    static char result[27];
    strcpy(result, teams);
    return result;
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    char* input_votes[1000];
    int size = 0;
    
    // Parse JSON array format: ["ABC","ACB","ABC","ACB","ACB"]
    char* ptr = line;
    
    // Skip opening '['
    while (*ptr && (*ptr == '[' || *ptr == ' ')) ptr++;
    
    while (*ptr && *ptr != ']') {
        // Skip spaces and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        
        // Check for opening quote
        if (*ptr == '"') {
            ptr++; // Skip opening quote
            char* start = ptr;
            
            // Find closing quote
            while (*ptr && *ptr != '"') ptr++;
            
            if (ptr > start) {
                int len = ptr - start;
                input_votes[size] = (char*)malloc(len + 1);
                strncpy(input_votes[size], start, len);
                input_votes[size][len] = '\0';
                size++;
            }
            
            if (*ptr == '"') ptr++; // Skip closing quote
        } else if (*ptr == ']') {
            break;
        } else {
            ptr++;
        }
    }
    
    char* result = solution(input_votes, size);
    printf("%s\n", result);
    
    // Free allocated memory
    for (int i = 0; i < size; i++) {
        free(input_votes[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × m)

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

✓ Linear 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