# CS50 Runoff Solution

Are you looking for the solution of Harvard’s CS50 PSet 3? Do you want the CS50 Runoff Solution of week 3?

If so you’re in the right place.

In this article, I’m going to share with you exactly how to solve the CS50 Runoff problem and will also share the CS50 Runoff solution with you.

Here’s how to solve the CS50 Runoff problem.

The first thing to do is to understand what we are trying to build. You can read the instructions from CS50’s website.

Runoff is different from the plurality problem that you just solved in the previous assignment of the same week. In order to properly understand the runoff problem, kindly refer to the problem explanation on CS50’s website.

Here’s my entire code for the CS50 Runoff Solution:

``````#include <cs50.h>
#include <stdio.h>
#include <string.h>

// Max voters and candidates
#define MAX_VOTERS 100
#define MAX_CANDIDATES 9

// preferences[i][j] is jth preference for voter i
int preferences[MAX_VOTERS][MAX_CANDIDATES];

// Candidates have name, vote count, eliminated status
typedef struct
{
string name;
bool eliminated;
} candidate;

// Array of candidates
candidate candidates[MAX_CANDIDATES];

// Numbers of voters and candidates
int voter_count;
int candidate_count;

// Function prototypes
bool vote(int voter, int rank, string name);
void tabulate(void);
bool print_winner(void);
int find_min(void);
bool is_tie(int min);
void eliminate(int min);

int main(int argc, string argv[])
{
// Check for invalid usage
if (argc < 2)
{
printf("Usage: runoff [candidate ...]\n");
return 1;
}

// Populate array of candidates
candidate_count = argc - 1;
if (candidate_count > MAX_CANDIDATES)
{
printf("Maximum number of candidates is %i\n", MAX_CANDIDATES);
return 2;
}
for (int i = 0; i < candidate_count; i++)
{
candidates[i].name = argv[i + 1];
candidates[i].eliminated = false;
}

voter_count = get_int("Number of voters: ");
if (voter_count > MAX_VOTERS)
{
printf("Maximum number of voters is %i\n", MAX_VOTERS);
return 3;
}

// Keep querying for votes
for (int i = 0; i < voter_count; i++)
{

// Query for each rank
for (int j = 0; j < candidate_count; j++)
{
string name = get_string("Rank %i: ", j + 1);

// Record vote, unless it's invalid
if (!vote(i, j, name))
{
printf("Invalid vote.\n");
return 4;
}
}

printf("\n");
}

// Keep holding runoffs until winner exists
while (true)
{
// Calculate votes given remaining candidates
tabulate();

// Check if election has been won
bool won = print_winner();
if (won)
{
break;
}

// Eliminate last-place candidates
int min = find_min();
bool tie = is_tie(min);

// If tie, everyone wins
if (tie)
{
for (int i = 0; i < candidate_count; i++)
{
if (!candidates[i].eliminated)
{
printf("%s\n", candidates[i].name);
}
}
break;
}

// Eliminate anyone with minimum number of votes
eliminate(min);

// Reset vote counts back to zero
for (int i = 0; i < candidate_count; i++)
{
}
}
return 0;
}

// Record preference if vote is valid
bool vote(int voter, int rank, string name)
{
// TODO
for (int i = 0; i < candidate_count; i++)
{
if (strcmp(candidates[i].name, name) == 0)
{
preferences[voter][rank] = i;
return true;
}
}
return false;
}

// Tabulate votes for non-eliminated candidates
void tabulate(void)
{
// TODO
for (int a = 0; a < voter_count; a++)
{
for (int b = 0; b < candidate_count; b++)
{
int c = preferences[a][b];
if (candidates[c].eliminated == false)
{
break;
}
}
}
return;
}

// Print the winner of the election, if there is one
bool print_winner(void)
{
// TODO
for (int i = 0; i < candidate_count; i++)
{
if (candidates[i].votes > (voter_count / 2))
{
printf("%s\n", candidates[i].name);
return true;
}
}
return false;
}

// Return the minimum number of votes any remaining candidate has
int find_min(void)
{
// TODO
int VoteCount = voter_count;
for (int i = 0; i < candidate_count; i++)
{
if (candidates[i].votes < VoteCount && candidates[i].eliminated == false)
{
}
}
return VoteCount;
}

// Return true if the election is tied between all candidates, false otherwise
bool is_tie(int min)
{
// TODO
int tieCount = 0;
int onRun = 0;

for (int i = 0; i < candidate_count; i++)
{
if (candidates[i].eliminated == false && candidates[i].votes == min)
{
tieCount++;
onRun++;
}
else if (candidates[i].eliminated == false)
{
onRun++;
}
}
if (tieCount == onRun)
{
return true;
}
return false;
}

// Eliminate the candidate (or candidates) in last place
void eliminate(int min)
{
// TODO
for (int i = 0; i < candidate_count; i++)
{
if (candidates[i].eliminated == false && candidates[i].votes == min)
{
candidates[i].eliminated = true;
}
}
return;
}
``````

If you have any confusion or problem, feel free to drop a comment down below. In the meantime, you can read these articles.