while loop not checking for condition in C

I just started Harvard's cs50 course and I am currently having difficulties understanding why my code for Lab 1: Population Growth keeps running forever. Below is the program for determining how long it takes for a population to reach a particular size. Near the end, my while loop isn't stopping even though the condition is reached.

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

int main(void)
{
    // Prompt for start size
    int i;
    do
    {
        i = get_int("Start size: ");
    }
    while (i < 9);

    // Prompt for end size
    int z;
    do
    {
        z = get_int("End size: ");
    }
    while (z < i);

    // year_count
    int n =  0;
//    Increase the year_count n for every loop until start size i reaches end size z
    while ((i < z) || (i != z))
    {
//        population after a year
        i = i + i / 3 - i / 4;
        n++;
//        the loop doesnt terminate itself so i had to force break
        if ((i > z) || (i == z))
        {
            break;
        }
    }

    // Print number of years
    printf("Years: %i\n", n);
}

With while ((i < z) || (i != z)), the loop fails to terminate because i passes z. For some inputs, there is never an iteration of the loop when i is exactly z. For example, with inputs of 10 and 100, i reaches 96 in one iteration and is then 104 in the next.

When i is 104, i < z is false but i != z is true. So the loop continues.

The loop test you want is i < z.

You could have discovered this by printing useful information in each loop iteration, such as:

printf("i = %d.\n", i);
printf("z = %d.\n", z);
printf("i < z = %d.\n", i < z);
printf("i != z = %d.\n", i != z);

That would have revealed to you how the conditions for the while were being evaluated.

It seems like the while loop in your code is not stopping because of the condition you have used.

while ((i < z) || (i != z))

If the target population size z is not met, the current population size i is checked to see if it is less than the target population size z. This condition has the drawback of always being true when i < z because i will never equal z until it does. This implies that even after the population has beyond the intended size, your loop will still be in operation.

You must modify the while loop's condition in order to correct this. Changing the logical OR (||) operator to the logical AND (&&) operator is one approach to accomplish this. By doing this, you can make sure that the loop only executes when i is lower than z and not equal to z. Here's

while (i < z) && (i != z))

This will continue the loop only while the current population size i is less than the target population size z. Once i becomes greater than or equal to z, the loop will terminate.

The condition while ((i < z) || (i != z)) may never be false if i passes the value of z without reaching it exactly. Note that (i < z) || (i != z) is redundant as all cases where (i < z) also match (i != z).

To achieve your goal, Determine how long it takes for a population to reach a particular size, the test should just be while (i < z) because you should stop as soon as i >= z. The loop should be simplified as:

    while (i < z) {
        // population after a year
        i += i / 3 - i / 4;
        n++;
    }

Note that there are some corner cases, where i may overflow as it passes z, eg: if z is INT_MAX (2147483647).

Here is a modified version:

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

int main(void) {
    // Prompt for start size
    int i;
    do { i = get_int("Start size: "); } while (i < 9);

    // Prompt for end size
    int z;
    do { z = get_int("End size: "); } while (z < i);

    // year_count
    int n =  0;
    // Increase the year_count n for every loop until start size i reaches end size z
    while (i < z) {
        // population after a year
        i += i / 3 - i / 4;
        n++;
    }

    // Print number of years
    printf("Years: %i\n", n);
    return 0;
}

To avoid the overflow, you could write this:

#include <limits.h>

...

    while (i < z) {
        // population after a year
        int growth = i / 3 - i / 4;
        // check for potential overflow
        if (i > INT_MAX - growth) {
            i = INT_MAX;
        } else {
            i += growth;
        }
        n++;
    }