find_min function and infinite loop when a candidate not winner in first instance

[admin]

Copy Code
Copied
Use a different Browser

// Return the minimum number of votes any remaining candidate has
int find_min(void)
{
int mini;
    for (int cc = 0; cc < candidate_count; cc++)
    {
        if (candidates[cc].votes < candidates[cc + 1].votes)
        {
            mini = candidates[cc].votes;
        }
    }
return mini;
return 0;
}

			

 

There must be something wrong with the above code. Not sure if line no. 12 and line no. 13 are okay. My understanding is if mini gets no integer value (tie case), return mini will be bypassed by return 0. Thought to put return mini within for loop on line no. 11 but that will not be the final mini value obtained by checking all the vote counts of candidates.

Here is the state of code currently. While the code apparently works correctly when the winning candidate is decided on first instance, there is an infinite loop if that not be the case.

Copy Code
Copied
Use a different Browser

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

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

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

// Candidates have name, vote count, eliminated status
typedef struct
{
    string name;
    int votes;
    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.name = argv;
        candidates.votes = 0;
        candidates.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("%i, %i, %s\n", i + 1, j + 1, candidates[preferences[j]].name);
        }
   }


//printf("complete");


    // 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.eliminated)
                {
                    printf("%s\n", candidates.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++)
        {
            candidates.votes = 0;
        }
    }
    return 0;
}



// Record preference if vote is valid
bool vote(int voter, int rank, string name)
{
    //printf("voter no (via local function taking value of voter as argument).: %i, rank selected (via local function taking value of rank as argument) %i\n", voter + 1, rank + 1);
    for (int t = 0; t < candidate_count; t++)
        {
            if(strcmp(name, candidates[t].name) == 0)
            {
            preferences[voter][rank] = t;
            //printf("preference of voter no. %i for rank %i is %s\n", voter + 1, rank + 1, candidates[t].name);
            return 4;
            }
        }
    return 0;
}



// Tabulate votes for non-eliminated candidates
void tabulate(void)
{
    int vc = 0;
    int cc = 0;

        for (vc = 0; vc < voter_count; vc++)
        {
            for (cc = 0; cc < candidate_count; cc++)
            {
                    if (candidates[preferences[vc][cc]].eliminated != 1)
                    {
                    int t = preferences[vc][cc];
                    candidates[t].votes = candidates[t].votes + 1;
                    printf("vote secured by %s for rank 1 is %i", candidates[t].name, candidates[t].votes);
                    break;
                    }
            }
        }
return;
}



// Print the winner of the election, if there is one
bool print_winner(void)
{
int necand = 0;
for (int cc = 0; cc < candidate_count; cc++)
{
    if (candidates[cc].eliminated == false)
        {
        necand = necand + 1;
        }
    }
for (int canc = 0; canc < candidate_count; canc++)
    {
        if (candidates[canc].votes > necand/2)
           {
            printf("winner is %s", candidates[canc].name);
            return true;
            break;
           }
    }
return false;
}



// Return the minimum number of votes any remaining candidate has
int find_min(void)
{
int mini;
    for (int cc = 0; cc < candidate_count; cc++)
    {
        if (candidates[cc].votes < candidates[cc + 1].votes)
        {
            mini = candidates[cc].votes;
        }
    }
return mini;
return 0;
}
// Return true if the election is tied between all candidates, false otherwise
bool is_tie(int min)
{
int tievalue;
    for (int cc = 0; cc < candidate_count; cc++)
    {
        tievalue = candidates[cc].votes;
        if (candidates[cc].votes != tievalue)
        {
            return 1;
        }
    }
    return false;
}

// Eliminate the candidate (or candidates) in last place
void eliminate(int min)
{
    for (int cc = 0; cc < candidate_count; cc++)
    {
        if (candidates[cc].votes == min)
        {
            candidates[cc].eliminated = 1;
        }
    }
    return;
}

			

 

---

Reply

---

https://edstem.org/us/courses/176/discussion/2392767?comment=5463010[learn_press_profile]

[Author]

Posts