cs50径流无限循环

Question

cs50 有这样一个练习，我们必须进行决选，然后当某人拥有超过 50% 的选票时打印获胜者。因此，为了在无法找到获胜者的情况下进行选举，它有一个 while 循环，该循环始终返回 true，直到“print_winner()”函数返回 false。但即使当我使用 print_winner 函数并且候选人拥有超过 50% 的选票时，循环也不会停止。

首先（当 print_winner() 函数还没有准备好时）我尝试查看我的所有代码，看看是否有一些错误，但我找不到它，然后我意识到我需要创建 print_winner() 函数至少，但是，即使功能完成，它也不起作用。

所以，我想知道这是否正常，因为代码尚未准备好，或者是否是一个真正的错误。

而且，如果这是一个真正的错误，我应该在哪里修复它？

这是代码：

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

// Max voters and candidates
#define MAX_VOTERS 100 // constante MAX de eleitores = 100
#define MAX_CANDIDATES 9 // constante MAX de candidatos = 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;
    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++) // loop que add os candidatos na array candidate
    {
        candidates[i].name = argv[i + 1];
        candidates[i].votes = 0;
        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++) // i ira gerar a quantidade de vezes que o loop j   sera iniciado
    {

        // 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++)
        {
            candidates[i].votes = 0;
        }
    }
    return 0;
}

// Record preference if vote is valid
bool vote(int voter, int rank, string name)
{
    // TODO
    for (int i = 0; i < voter_count; i++) //passa por todos os eleitores
    {
        if (strcmp(name, candidates[i].name) == 0) // compara os nomes
        {
            preferences[voter][rank] = i; // preferences[eleitor 0][1° opçao 0] = candidato
            return true;
        }
    }
    return false;
}


// Tabulate votes for non-eliminated candidates
void tabulate(void)
{
    // TODO

    // mede o tamanho da array
    int lenght = sizeof(preferences) / sizeof(preferences[0]);

    for (int i = 0; i < voter_count; i++)
    {
        for (int j = 0; j < candidate_count; j++)
        {
            if (candidates[preferences[i][j]].eliminated == false)
            {
                break;
            }
            else if (candidates[preferences[i][j]].eliminated == true)
            {
                candidates[preferences[i][j + 1]].votes++;
            }
        }
        printf("\n");
     } 

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;
            break;
        }
    }
    return false;
}

// Return the minimum number of votes any remaining candidate has
int find_min(void)
{
    // TODO
    return 0;
}

// Return true if the election is tied between all candidates, false otherwise
bool is_tie(int min)
{
    // TODO
    return false;
}

// Eliminate the candidate (or candidates) in last place
void eliminate(int min)
{
    // TODO
    return;
}

Answer 1

当时的无限循环是正常，因为代码还没有准备好。需要完成函数 find_min、is_Tie 和 eliminate，程序才能正常运行。

但是为什么呢？在前面的代码中，函数find_min、is_Tie和eliminate位于一个循环中，只有在获得胜利者时才会被打破。当代码无法计算所有选票、淘汰所有得票数不超过 50% 的人或检查是否平局时，代码无法返回获胜者。

    // 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++)
    {
        candidates[i].votes = 0;
    }
}