0

Is there any reason why the while-loop in the below code will not work?

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

// Max number of candidates #define MAX 9

// preferences[i][j] is number of voters who prefer i over j int preferences[MAX][MAX];

// locked[i][j] means i is locked in over j bool locked[MAX][MAX];

// Each pair has a winner, loser typedef struct { int winner; int loser; } pair;

// Array of candidates string candidates[MAX]; pair pairs[MAX * (MAX - 1) / 2];

int pair_count; int candidate_count;

// Function prototypes bool vote(int rank, string name, int ranks[]); void record_preferences(int ranks[]); void add_pairs(void); void sort_pairs(void); void lock_pairs(void); void print_winner(void);

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

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

// Clear graph of locked in pairs
for (int i = 0; i < candidate_count; i++)
{
    for (int j = 0; j < candidate_count; j++)
    {
        locked[i][j] = false;
    }
}

pair_count = 0;
int voter_count = get_int("Number of voters: ");

// Query for votes
for (int i = 0; i < voter_count; i++)
{
    // ranks[i] is voter's ith preference
    int ranks[candidate_count];

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

        if (!vote(j, name, ranks))
        {
            printf("Invalid vote.\n");
            return 3;
        }
    }

    record_preferences(ranks);

    printf("\n");
}

add_pairs();
sort_pairs();
lock_pairs();
print_winner();
return 0;

}

// Update ranks given a new vote bool vote(int rank, string name, int ranks[]) { // TODO

//int x = 0;

for (int i = 0; i < candidate_count; i++)
{
    if (strcmp(candidates[i], name) == 0)
    {
        //x = i;
        ranks[rank] = i;
        return true;
        break;
    }
}
return false;

}

// Update preferences given one voter's ranks void record_preferences(int ranks[]) { // TODO

// initialize baseline values in array

//for (int ii = 0; ii < candidate_count; ii++)
//{
    //for (int jj = 0; jj < candidate_count; jj++)
    //{
        //preferences[ranks[ii]][ranks[jj]] = 0;
    //}
//}    

for (int i = 0; i < candidate_count; i++)
{
    for (int j = i + 1; j < candidate_count; j++)
    {
        preferences[ranks[i]][ranks[j]] += 1;
    }
}
return;

}

// Record pairs of candidates where one is preferred over the other void add_pairs(void) { // TODO

int k = 0;

for (int i = 0; i < candidate_count; i++)
{
    for (int j = 0; j < i; j++)
    {
        if (preferences[i][j] == preferences[j][i])
        {
            //is_tie
        }
        else if (preferences[i][j] > preferences[j][i])
        {
            pairs[k].winner = i;
            pairs[k].loser = j;
            k++;
        }
        else if (preferences[i][j] < preferences[j][i])
        {
            pairs[k].winner = j;
            pairs[k].loser = i;
            k++;
        }
    }
}
pair_count = k;
return;

}

// Sort pairs in decreasing order by strength of victory void sort_pairs(void) { // TODO

int unsorted_pairs[pair_count];

for (int i = 0; i < (pair_count + 1); i++)
{
    int x = pairs[i].winner;
    int y = pairs[i].loser;

    int diff = preferences[x][y] - preferences[y][x];

    if (diff < 0)
    {
        diff = diff * -1;
    }

    unsorted_pairs[i] = diff * -1; // to accommodate the below sorting algorithm which sorts from small to large
}

// Selection Sort Algorithm

for (int j = 0; j < pair_count + 1; j++)
{
    int min = j;

    for (int k = j + 1; k < pair_count + 1; k++)
    {
        if (unsorted_pairs[k] < unsorted_pairs[min])
        {
            min = k;
        }
        if (min != j)
        {
            int swap = unsorted_pairs[j];
            unsorted_pairs[j] = unsorted_pairs[min];
            unsorted_pairs[min] = swap;

            pair swap2 = pairs[j];
            pairs[j] = pairs[min];
            pairs[min] = swap2;
        }
    }
}
return;

}

// Lock pairs into the candidate graph in order, without creating cycles void lock_pairs(void) { // TODO

int k = 0;
int sum = 0;

while (sum != 9 || k < (pair_count + 1))
{
    sum = 0;
    locked[pairs[k].winner][pairs[k].loser] = true;
    k++;

    for (int j = 0; j < MAX; j++)
    {
        for (int i = 0; i < MAX; i++)
        {
            if (locked[i][j] == true)
            {
                sum += 1;
                break;
            }
        }
    }
}
return;

}

// Print the winner of the election void print_winner(void) { // TODO

int winner = 0;
int sum = 0;

for (int j = 0; j < MAX; j++)
{
    for (int i = 0; i < MAX; i++)
    {
        if (locked[i][j] == false)
        {
            sum += 1;

            if (sum == 9)
            {
                winner = j;
                break;
            }
        }
    }
}

printf("%s\n", candidates[winner]);
return;

}

You must log in to answer this question.

Browse other questions tagged .