Tous les défis
Moyen 0 résolus 0 % de réussite

Runoff Election

Run an instant runoff election on ranked ballots, eliminating the weakest candidates round by round.

Ce que vous allez apprendre

  • Count each ballot for its top remaining choice
  • Detect a majority winner and a full tie
  • Eliminate all candidates with the lowest count

Problème

Afficher la traduction

In an instant runoff election, every voter ranks all the candidates. The count goes in rounds:

  1. Each ballot counts as one vote for its highest-ranked candidate who is still in the race.
  2. If a candidate has more than half of all ballots, that candidate wins.
  3. Otherwise, if every remaining candidate has the same number of votes, they are all tied and the election ends.
  4. Otherwise, every remaining candidate with the fewest votes is eliminated (all of them at once if several share the lowest count), and a new round starts.

Implement runoff_election(candidates, ballots).

Input

candidates: The candidates' names. Candidate i is candidates[i].

ballots: One row per voter: the candidate numbers (0-based) from most preferred to least preferred. Each row lists every candidate exactly once.

Output

Return a list with the winner's name, or, if the election ends in a tie, the names of all tied candidates in the order they appear in candidates. With no ballots, all candidates are tied.

Contraintes

1 ≤ length of candidates ≤ 9

0 ≤ number of ballots ≤ 200

Exemples

Exemple 1
Entrée :
candidates = ["Ana", "Bo", "Cy"]
ballots = [
    [0, 1, 2],
    [0, 2, 1],
    [1, 2, 0],
    [1, 0, 2],
    [2, 0, 1]
]

Sortie attendue :
expected = ["Ana"]
Entrée :
std::vector<std::string> candidates = {"Ana", "Bo", "Cy"};
std::vector<std::vector<long long>> ballots = {
    {0, 1, 2},
    {0, 2, 1},
    {1, 2, 0},
    {1, 0, 2},
    {2, 0, 1}
};

Sortie attendue :
std::vector<std::string> expected = {"Ana"};
Entrée :
string[] candidates = new string[] {"Ana", "Bo", "Cy"};
long[][] ballots = new long[][] {
    new long[] {0, 1, 2},
    new long[] {0, 2, 1},
    new long[] {1, 2, 0},
    new long[] {1, 0, 2},
    new long[] {2, 0, 1}
};

Sortie attendue :
string[] expected = new string[] {"Ana"};

Explication

Round 1: Ana 2, Bo 2, Cy 1; nobody has more than 2.5, so Cy is out. Cy's ballot moves to Ana, who wins with 3 of 5: ["Ana"].

Exemple 2
Entrée :
candidates = ["Ana", "Bo", "Cy"]
ballots = [
    [0, 1, 2],
    [0, 1, 2],
    [1, 2, 0],
    [1, 2, 0],
    [2, 1, 0],
    [2, 1, 0]
]

Sortie attendue :
expected = ["Ana", "Bo", "Cy"]
Entrée :
std::vector<std::string> candidates = {"Ana", "Bo", "Cy"};
std::vector<std::vector<long long>> ballots = {
    {0, 1, 2},
    {0, 1, 2},
    {1, 2, 0},
    {1, 2, 0},
    {2, 1, 0},
    {2, 1, 0}
};

Sortie attendue :
std::vector<std::string> expected = {"Ana", "Bo", "Cy"};
Entrée :
string[] candidates = new string[] {"Ana", "Bo", "Cy"};
long[][] ballots = new long[][] {
    new long[] {0, 1, 2},
    new long[] {0, 1, 2},
    new long[] {1, 2, 0},
    new long[] {1, 2, 0},
    new long[] {2, 1, 0},
    new long[] {2, 1, 0}
};

Sortie attendue :
string[] expected = new string[] {"Ana", "Bo", "Cy"};

Explication

Every candidate has 2 first-place votes out of 6, so the three of them are tied: ["Ana", "Bo", "Cy"].

Comment l'aborder

Essayez d'abord seul, puis ouvrez les indices un par un.

Indice 1

Keep a true/false list of who is still in the race and recount from scratch every round.

Indice 2

A majority means votes × 2 greater than the number of ballots.

Indice 3

Find the lowest count among remaining candidates only; if everyone remaining has it, the election is a tie.

Complexité attendue

O(c^2 × b) time, O(c) extra space

Références

Ce défi a été adapté pour CodeUtility. Suivez l'énoncé et les contraintes ci-dessus.

La meilleure solution validée de chaque codeur. Les plus rapides, les plus légères et les mieux notées passent devant.

Aucune solution validée pour l'instant. Résolvez-le et prenez la première place.

Apprenez des autres

Solutions de la communauté

Aucune solution publiée pour l'instant. Résolvez ce défi pour partager la première.