Program won't stop running

[jdwright]

Ok, I just wrote this program for a class. It builds but the output is never produced. I need help figuring out why.

#include <iostream>
#include <cstdlib>
using namespace std;

int checkSquares(int [][22]);
void jumpFleas(int [][22], int [][22], int);
void resetGrid(int [][22], int [][22]);
void zeroOut(int [][22]);
void initialize(int [][22]);
void getTotals(int, int, int, int);
void getMinMax(int, int, int);
void displayInfo(int, int, int, int);

int main()
{
    int simRun = 1;
    int min = 10000, max = 0, jumps = 0, loss = 0, runs = 0;
    int totalJumps = 0, totalLoss = 0, TOTALJ = 0, TOTALL = 0;
    int grid1[22][22];
    int grid2[22][22];
    initialize(grid1);
    zeroOut(grid2);
    
    while (simRun < 501)
    {
        checkSquares(grid1);
        while (runs != 1)
        {
            jumpFleas (grid1, grid2, loss);
            jumps += 1;
            runs = checkSquares(grid2);
            resetGrid(grid1, grid2);
            zeroOut(grid2);
        }
        getTotals(jumps, loss, totalJumps, totalLoss);
        simRun++;
    }
    
    getTotals(totalJumps, totalLoss, TOTALJ, TOTALL);
    getMinMax(totalJumps, min, max);

    displayInfo(TOTALJ, TOTALL, min, max);


    return 0;
}

void jumpFleas(int grid1[][22], int grid2[][22], int loss)
{
    int r,c, move;
    
    for (r=1; r<21; r++)
    {
        for (c=1; c<21; c++)
        {
            move = (rand() % 100) + 1;
            if (move>0 && move<16)
            {
                grid2[r][c] += grid1[r][c];
            }
            if (move>15 && move<31)
            {
                grid2[r+1][c] += grid1 [r][c];
                if ((r+1) == 22)
                {
                    loss += 1;
                }
            }
            if (move>30 && move<36)
            {
                grid2[r+1][c+1] += grid1[r][c];
                if (((r+1) == 22) || ((c+1) == 22))
                {
                    loss += 1;
                }
            }
            if (move>35 && move<56)
            {
                grid2[r][c+1] += grid1 [r][c];
                if ((c+1) == 22)
                {
                    loss += 1;
                }
            }
            if (move>55 && move<61)
            {
                grid2[r-1][c+1] += grid1 [r][c];
                if (((r-1) == 0) || ((c+1) == 22))
                {
                    loss += 1;
                }
            }
            if (move>60 && move<76)
            {
                grid2[r-1][c] += grid1[r][c];
                if ((r-1) == 0)
                {
                    loss += 1;
                }
            }
            if (move>75 && move<81)
            {
                grid2[r-1][c-1] += grid1[r][c];
                if (((r-1) == 0) || ((c-1) == 0))
                {
                    loss += 1;
                }
            }
            if (move>80 && move<96)
            {
                grid2[r][c-1] += grid1[r][c];
                if ((c-1) == 0)
                {
                    loss += 1;
                }
            }
            if (move>95 && move<101)
            {
                grid2[r+1][c-1] += grid1[r][c];
                if (((r+1) == 22) || ((c-1) == 0))
                {
                    loss += 1;
                }
            }
        }
    }
}

int checkSquares(int grid2[][22])
{
    int r,c, runs;
    int count = 0;
    
    for (r=1; r<21; r++)
        for (c=1; c<21; c++)
        {
            while (grid2[r][c] == 0)
            {
                count += 1;
            }
        }
    if (count > 149)
    {
        runs = 1;
    }
    else
    {
        runs = 0;
    }
    
    return runs;
}

void getTotals(int jumps, int loss, int totalJ, int totalL)
{
    totalJ += jumps;
    totalL += loss;
}

void getMinMax (int jumps, int min, int max)
{
    if (jumps < min)
    {
        min = jumps;
    }
    if (jumps > max)
    {
        max = jumps;
    }
}

void resetGrid(int grid1[][22], int grid2[][22])
{
    int r,c;
    for (r=1; r<21; r++)
    {
        for (c=1; c<21; c++)
        {
            grid1[r][c] = grid2[r][c];
        }
    }
}

void zeroOut(int grid2[][22])
{
    int r,c;
    for (r=1; r<21; r++)
    {
        for (c=1; c<21; c++)
        {
            grid2[r][c] = 0;
        }
    }
}

void initialize(int grid1[][22])
{
    int r,c;
    for (r=1; r<21; r++)
    {
        for (c=1; c<21; c++)
        {
            grid1[r][c] = 1;
        }
    }
}

void displayInfo(int TOTALJ, int TOTALL, int min, int max)
{
    int avgJ, clearTime, avgL, maxTime, minTime;
    avgJ = TOTALJ / 500;
    clearTime = (TOTALJ * 8) / 5;
    maxTime = (max * 8) / 5;
    minTime = (min * 8) / 5;
    avgL = TOTALL / 500;
    
    cout << "The average number of jumps before fire: " << avgJ << endl;
    cout << "The amount of time needed to clear the area: " << clearTime << endl;
    cout << "The shortest time: " << minTime << endl;
    cout << "The longest time: " << maxTime << endl;
    cout << "The average number of fleas lost before fire: " << avgL << endl;
}

[ne555]

            while (grid2[r][c] == 0)
            {
                count += 1;
            }

[jdwright]

That is just to count how many squares have 0 in them.. I can't see any problem with it.

[long double main]

Then let's walk through those few lines one by one to see if you still can't find any problem with it.
Let's say that r = 5, c = 4, and grid2 is 0 at that point.

Line 137: r = 5, c = 4, grid2[5][4] == 0 so we enter the while loop.
Line 139: Increment count.

Next iteration:
Line 137: r is still 5, c is still 4, so grid2[5][4] == 0 so we enter the while loop.
Line 139: Increment count.

Next iteration:
Line 137: r is still 5, c is still 4, and we never touched grid2, so grid2[5][4] is still 0, so we enter the while loop.
Line 139: Increment count.

Next iteration:
...get the point?

In short, I think you meant to put if instead of while.

[jdwright]

I see the problem. Thank you for explaining. Now, after my code finally runs, I have a problem with the loop:

while (simRun < 501)
    {
        checkSquares(grid1);
        while (runs != 1)
        {
            jumpFleas (grid1, grid2, loss);
            jumps += 1;
            runs = checkSquares(grid2);
            resetGrid(grid1, grid2);
            zeroOut(grid2);
        }
        getTotals(jumps, loss, totalJumps, totalLoss);
        simRun++;
    }

After I realized my output wasn't what it should be, I did some testing and I realized that my while (runs != 1) loop is only executing one time for each of the 500 runs. Is this because of the rand() generating the same sequence of numbers every time that function is called? If so, how do I fix that. I know there is the concept of seeding, but I don't understand how that works.

[ne555]

When `runs' become 1 you exit the loop.
the next time, `runs' is still 1.

while (simRun < 501)
    {
        int runs=0; //reset. (also, limiting the scope)
        checkSquares(grid1);
        while (runs != 1)
        {
            jumpFleas (grid1, grid2, loss);
            jumps += 1;
            runs = checkSquares(grid2);
            resetGrid(grid1, grid2);
            zeroOut(grid2);
        }
        getTotals(jumps, loss, totalJumps, totalLoss);
        simRun++;
    }

for the way it is used, `runs' should be a bool