Election Results - Practice Coding Problems

Election Results - Problem

Database Medium

You're analyzing the results of a modern city election where voters can cast their ballots for multiple candidates or choose not to vote at all. Here's the twist: when someone votes for multiple candidates, their single vote gets equally split among all their chosen candidates.

For example, if Alice votes for both candidate "John" and candidate "Mary", then John receives 0.5 votes and Mary receives 0.5 votes from Alice.

Your task: Determine which candidate(s) won the election by receiving the most total votes. If there's a tie for the highest vote count, return all tied candidates.

Input: A database table Votes with columns voter (varchar) and candidate (varchar). Each row represents one voter's choice for one candidate.

Output: The name(s) of the winning candidate(s), ordered alphabetically.

Input & Output

example_1.sql — Basic Election

$ Input: Votes table: | voter | candidate | |-------|----------| | Alice | John | | Alice | Mary | | Bob | John | | Carol | Mary |

› Output: | candidate | |----------| | John | | Mary |

💡 Note: Alice votes for 2 candidates, so John and Mary each get 0.5 votes from Alice. Bob gives John 1.0 vote, Carol gives Mary 1.0 vote. Final: John=1.5, Mary=1.5 (tie).

example_2.sql — Clear Winner

$ Input: Votes table: | voter | candidate | |-------|----------| | Alice | John | | Bob | John | | Carol | Mary |

› Output: | candidate | |----------| | John |

💡 Note: Alice gives John 1.0 vote, Bob gives John 1.0 vote, Carol gives Mary 1.0 vote. Final: John=2.0, Mary=1.0. John wins.

example_3.sql — Heavy Vote Splitting

$ Input: Votes table: | voter | candidate | |-------|----------| | Alice | John | | Alice | Mary | | Alice | Peter | | Bob | John |

› Output: | candidate | |----------| | John |

💡 Note: Alice splits her vote 3 ways: John, Mary, and Peter each get 0.33 votes from Alice. Bob gives John 1.0 vote. Final: John=1.33, Mary=0.33, Peter=0.33.

Visualization

Tap to expand

Understanding the Visualization

Vote Collection

Each voter submits their choices - they can pick multiple candidates

Vote Splitting

Each voter's single vote gets divided equally among their chosen candidates

Vote Counting

Sum up all fractional votes received by each candidate

Winner Selection

Find candidate(s) with the highest vote total

Key Takeaway

🎯 Key Insight: The key is recognizing that each voter's total influence is always 1.0, regardless of how many candidates they vote for. Window functions let us calculate the split efficiently in SQL.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through data with efficient window function calculations

✓ Linear Growth

Space Complexity

O(k)

Space proportional to number of unique candidates (k), not total votes (n)

✓ Linear Space

Constraints

1 ≤ number of votes ≤ 10⁴
1 ≤ voter.length, candidate.length ≤ 20
voter and candidate contain only lowercase English letters
Each voter can vote for multiple candidates or not vote at all
The combination (voter, candidate) is unique in the table

Asked in

f Facebook 45 G Google 38 a Amazon 32 ⊞ Microsoft 28 N Netflix 22

The optimal solution uses SQL window functions to calculate vote splits efficiently. Use COUNT(*) OVER (PARTITION BY voter) to count each voter's choices, then calculate fractional votes as 1.0/count. Group by candidate, sum the fractional votes, and filter for the maximum total using a subquery or window function.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Subquery for Each Candidate)	O(n²)	O(n)	For each candidate, use a subquery to count their votes by checking all voters
SQL Window Functions (Optimal)	O(n)	O(k)	Use window functions to calculate vote splits and totals in a single query

Brute Force (Subquery for Each Candidate) — Algorithm Steps

Get all unique candidates from the votes table
For each candidate, use a subquery to find all voters who voted for them
For each of those voters, count how many total candidates they voted for
Sum up 1/count for each voter to get the candidate's total votes
Find the maximum vote count and return all candidates with that count

Visualization

Tap to expand

Step-by-Step Walkthrough

Count voter choices

For each voter, count how many candidates they voted for

Calculate candidate votes

For each vote, add fractional vote (1/voter_choices) to candidate

Find maximum

Scan through all candidate totals to find the maximum

Return winners

Collect all candidates with maximum vote count

Code -

solution.c — C

// Brute force simulation in C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_CANDIDATES 100
#define MAX_VOTERS 100
#define MAX_NAME_LEN 50

typedef struct {
    char voter[MAX_NAME_LEN];
    char candidate[MAX_NAME_LEN];
} Vote;

typedef struct {
    char name[MAX_NAME_LEN];
    double votes;
} CandidateVote;

int compareStrings(const void *a, const void *b) {
    return strcmp((char*)a, (char*)b);
}

int electionResultsBruteForce(Vote votes[], int voteCount, char winners[][MAX_NAME_LEN]) {
    char voterNames[MAX_VOTERS][MAX_NAME_LEN];
    int voterChoices[MAX_VOTERS] = {0};
    int voterCount = 0;
    
    CandidateVote candidates[MAX_CANDIDATES];
    int candidateCount = 0;
    
    // Count voter choices and build candidate list
    for (int i = 0; i < voteCount; i++) {
        // Find or add voter
        int voterIdx = -1;
        for (int j = 0; j < voterCount; j++) {
            if (strcmp(voterNames[j], votes[i].voter) == 0) {
                voterIdx = j;
                break;
            }
        }
        if (voterIdx == -1) {
            strcpy(voterNames[voterCount], votes[i].voter);
            voterIdx = voterCount++;
        }
        voterChoices[voterIdx]++;
        
        // Find or add candidate
        int candIdx = -1;
        for (int j = 0; j < candidateCount; j++) {
            if (strcmp(candidates[j].name, votes[i].candidate) == 0) {
                candIdx = j;
                break;
            }
        }
        if (candIdx == -1) {
            strcpy(candidates[candidateCount].name, votes[i].candidate);
            candidates[candidateCount].votes = 0.0;
            candIdx = candidateCount++;
        }
    }
    
    // Calculate votes
    for (int i = 0; i < voteCount; i++) {
        int voterIdx = -1;
        for (int j = 0; j < voterCount; j++) {
            if (strcmp(voterNames[j], votes[i].voter) == 0) {
                voterIdx = j;
                break;
            }
        }
        
        int candIdx = -1;
        for (int j = 0; j < candidateCount; j++) {
            if (strcmp(candidates[j].name, votes[i].candidate) == 0) {
                candIdx = j;
                break;
            }
        }
        
        candidates[candIdx].votes += 1.0 / voterChoices[voterIdx];
    }
    
    // Find max votes
    double maxVotes = 0;
    for (int i = 0; i < candidateCount; i++) {
        if (candidates[i].votes > maxVotes) {
            maxVotes = candidates[i].votes;
        }
    }
    
    // Get winners
    int winnerCount = 0;
    for (int i = 0; i < candidateCount; i++) {
        if (candidates[i].votes == maxVotes) {
            strcpy(winners[winnerCount++], candidates[i].name);
        }
    }
    
    // Sort winners
    qsort(winners, winnerCount, MAX_NAME_LEN, compareStrings);
    
    return winnerCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each candidate, we scan through all votes to calculate their total

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing intermediate results and candidate vote counts

⚡ Linearithmic Space

Constraints

1 ≤ number of votes ≤ 10⁴
1 ≤ voter.length, candidate.length ≤ 20
voter and candidate contain only lowercase English letters
Each voter can vote for multiple candidates or not vote at all
The combination (voter, candidate) is unique in the table

24.6K Views

Medium-High Frequency

~18 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Subquery for Each Candidate) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler