While Loop Exercises With Solutions

Getting Your Head Around While Loops

While loops are one of those constructs that seem straightforward until you actually need to write one from scratch. The basic idea is simple: keep doing something as long as a condition stays true. But the devil is in the edge cases, and that is where most people trip up. I have spent years debugging code written by junior developers, and the single most common mistake is an infinite loop caused by forgetting to update the loop variable. It sounds ridiculous, but it happens constantly. I once spent two hours tracking down a hanging process only to find a for loop masquerading as a while loop because someone changed the structure and forgot to adjust the counter.

While Loop Exercises With Solutions

Below are exercises that progress from basic to moderately challenging. Each one includes a solution with explanation. Write a while loop that calculates the sum of all digits in a given integer. Solution:

n = 12345
total = 0
while n > 0:
    digit = n % 10
    total += digit
    n = n // 10
print(total) This works by extracting the rightmost digit with the modulo operator, adding it to the running total, then integer-dividing the number by 10 to shift everything one place to the right. The loop terminates when n reaches zero.

Exercise 2: Reverse a Number

Use a while loop to reverse the digits of an integer. Solution: n = 6789
reversed_num = 0
while n > 0:
    digit = n % 10
    reversed_num = reversed_num * 10 + digit
    n = n // 10
print(reversed_num)

The key difference from Exercise 1 is that we multiply the accumulator by 10 before adding the new digit. This builds the reversed number in place rather than just summing the digits.

Exercise 3: Find the Greatest Common Divisor

Implement the Euclidean algorithm using a while loop to find the GCD of two numbers. Solution: a = 48
b = 18
while b != 0:
    temp = b
    b = a % b
    a = temp
print(a)

The Euclidean algorithm repeatedly replaces the larger number with the remainder of dividing the two numbers. When the remainder hits zero, the last non-zero remainder is your GCD. This is about as efficient as it gets for integer GCD calculations. The Python math.gcd() function uses an optimized C implementation of this same algorithm, but writing it out by hand forces you to understand what is actually happening under the hood.

Exercise 4: Password Validation Loop

Create a program that repeatedly asks the user for a password until they enter one that is at least 8 characters long and contains at least one digit. Solution: password = ""
while len(password) < 8 or not any(c.isdigit() for c in password):
    password = input("Enter a password (at least 8 chars with one digit): ")
print("Password accepted")

I worked on a legacy system once where the password validation was done with a for loop instead of a while loop, which meant the input collection logic was completely broken. The developer tried to use range() with a flag variable to control the loop, and it was unmaintainable garbage. A while loop with a clear exit condition is the right tool here. You could add a maximum attempt limit to prevent an actual infinite loop if the user just refuses to comply, which is a good defensive practice.

Exercise 5: Print a Fibonacci Sequence Up to N

Generate the Fibonacci sequence up to a maximum value N using a while loop. Solution: N = 100
a, b = 0, 1
while a <= N:
    print(a)
    a, b = b, a + b

The tuple unpacking on the last line is worth paying attention to. Python evaluates the right side first, so a and b are updated simultaneously. If you wrote this as two separate assignment statements without tuple unpacking, you would get incorrect results because a would be updated before b used its old value.

Exercise 6: Prime Number Checker

Determine whether a given number is prime using a while loop. Solution: n = 97
if n < 2:
    print("Not prime")
else:
    i = 2
    is_prime = True
    while i * i <= n:
        if n % i == 0:
            is_prime = False
            break
        i += 1
    if is_prime:
        print("Prime")
    else:
        print("Not prime")

Notice the loop condition is i * i = n rather than i n. This is a significant optimization. You only need to check divisors up to the square root of n because if n has a factor larger than its square root, the corresponding cofactor must be smaller than the square root and would have already been found. For large numbers, this cuts the number of iterations dramatically. Checking every number up to 97 would take 95 iterations. Checking up to the square root takes only 9.

Common Pitfalls to Watch Out For

Off-by-one errors are the most frequent issue with while loops. It is incredibly easy to write while i <= n when you meant while i < n, or vice versa. The fix is usually to trace through the loop manually with a small example and verify the boundary conditions. Another problem is mutation inside the loop body that you do not expect. I once inherited code where a while loop was iterating over a list, but items were being appended to that same list inside the loop body. The loop never terminated because the condition depended on the list length, which kept growing. This is a classic case where a for loop over a copy or a different iteration strategy would have been safer. While loops also have a natural weakness when the number of iterations is known in advance. If you know you need to do something exactly ten times, a while loop with a manual counter is needlessly verbose and introduces more opportunity for bugs. Use a for loop in those cases. The while loop shines when the termination condition is based on data or user input rather than a fixed count.

When While Loops Are the Right Call

Event-driven programming is one area where while loops are essentially mandatory. Reading from a network socket until the connection closes, processing input until a sentinel value appears, or polling a service until it becomes ready are all scenarios where the iteration count is unknowable ahead of time. In these cases, a while True loop with an explicit break condition is the standard pattern. One thing people miss is that while loops can be combined with else clauses in Python. The else block executes only if the loop completed normally without hitting a break statement. This is useful for search patterns where you want to run fallback logic only if the item was not found. n = 42
target = 99
i = 0
while i < len(numbers):
    if numbers[i] == target:
        print(f"Found at index {i}")
        break
    i += 1
else:
    print("Target not found")

This is a Python-specific feature and not available in most other languages. It can make the code cleaner, but it can also confuse readers who are not familiar with it, so use it judiciously.

While Loop Exercises With Solutions

Here is a downloadable summary of all the exercises covered above. The exercises are organized by difficulty level and include comments in the code explaining each step. Practice is what actually makes this stick. Reading through solutions without writing the code yourself will not build the muscle memory you need.