C Programming Loop Exercises: 30 Practice Problems with Solutions

#include <stdio.h>

int main() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);

    if (num > 0) {
        printf("%d is a Positive number.\n", num);
    } else if (num < 0) {
        printf("%d is a Negative number.\n", num);
    } else {
        printf("The number is Zero.\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

This uses a multi-way decision structure.

• The first if checks the most common case: num > 0.
• If the first check is false, the else if checks the second case: num < 0. This is more efficient than checking all possibilities separately.
• If both the if and the else if conditions are false, the final else block is executed, correctly identifying the number as zero.

#include <stdio.h>

int main() {
    char op;
    double n1, n2;

    printf("Enter operator (+, -, *, /): \n");
    scanf(" %c", &op); // Note the space before %c to handle whitespace
    printf("Enter two operands: \n");
    scanf("%lf %lf", &n1, &n2);

    switch (op) {
        case '+':
            printf("%.2lf + %.2lf = %.2lf\n", n1, n2, n1 + n2);
            break;
        case '-':
            printf("%.2lf - %.2lf = %.2lf\n", n1, n2, n1 - n2);
            break;
        case '*':
            printf("%.2lf * %.2lf = %.2lf\n", n1, n2, n1 * n2);
            break;
        case '/':
            if (n2 != 0) {
                printf("%.2lf / %.2lf = %.2lf\n", n1, n2, n1 / n2);
            } else {
                printf("Error: Division by zero is not allowed.\n");
            }
            break;
        default:
            printf("Error: Invalid operator.\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

The switch statement is ideal for selecting one of many code blocks to execute.

• The expression being evaluated is the operator variable op.
• Each case label ('+', '-', etc.) corresponds to a possible value of op.
• The break keyword is crucial; it terminates the switch statement after a case is handled, preventing fall-through into the next case.
• The / case includes an if-else statement to prevent the program from crashing on division by zero.
• The default case catches any operator that wasn’t matched by the specific cases.

#include <stdio.h>

int main() {
    int i;
    // i=1 (Initialization); i<=10 (Condition); i++ (Update/Iteration)
    for (i = 1; i <= 10; i++) {
        printf("%d\n", i);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

The for loop is the best choice when the number of iterations is known beforehand.

1. Initialization (i = 1): The counter i starts at 1. This happens once.
2. Condition (i <= 10): The loop continues as long as i is less than or equal to 10.
3. Body: printf("%d\n", i); prints the current value of i.
4. Update (i++): After the body executes, i is incremented by 1. The process repeats from step 2.

#include <stdio.h>
int main() {
    int i = 1;
    do {
        printf("%d ", i);
        i += 2;
    } while (i <= 100);
    return 0;
}Code language: C++ (cpp)

Explanation:

Unlike for and while, this do while loop runs the body first before checking the condition. Here, i begins at 1, and after each print, it is incremented by 2 to move to the next odd number. The loop continues until i becomes greater than 100.

#include <stdio.h>

int main() {
    int count = 10;

    while (count >= 1) {
        printf("%d\n", count);
        count--; // Decrement the counter
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

The while loop is suitable when you need a loop to continue based on a condition, and the number of repetitions isn’t fixed or is harder to determine initially.

• The variable count is initialized to 10.
• The loop checks the condition: count >= 1.
• If true, the number is printed, and count is decremented (count--).
• The loop repeats until count becomes 0, making the condition false and terminating the loop

#include <stdio.h>

int main() {
    int N = 5, i;
    long long sum = 0; // Use long long for potentially large sums

    for (i = 1; i <= N; i++) {
        sum += i; // Equivalent to: sum = sum + i;
    }

    printf("The sum of numbers from 1 to %d is: %lld\n", N, sum);

    return 0;
}Code language: C++ (cpp)

Explanation:

• A long long type is used for sum to ensure it can hold the result for large values of N without integer overflow.
• The for loop iterates from i=1 up to i=N.
• In the loop body, sum += i; updates the sum by adding the current value of i to the running total. When the loop finishes, sum holds the final result.

#include <stdio.h>
int main() {
    int sum = 0;
    for (int i = 1; i <= 20; i++) {
        if (i % 2 == 0) {
            sum += i;
        }
    }
    printf("Sum of even numbers = %d", sum);
    return 0;
}Code language: C++ (cpp)

Explanation:

The loop runs from 1 to 20. Each time, it checks if i is even. If true, it adds the number to sum. At the end, the total is printed, which will be 110.

#include <stdio.h>

int main() {
    int num = 2, i;

    printf("--- Multiplication Table for %d ---\n", num);

    for (i = 1; i <= 10; i++) {
        printf("%d x %d = %d\n", num, i, num * i);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

A for loop is used to handle the 10 iterations needed for the standard multiplication table.

• The loop counter i acts as the multiplier, going from 1 to 10.
• Inside the loop, the printf statement calculates the product (num * i) and neatly formats the output for the user, clearly showing the factors and the result.

#include <stdio.h>

int main() {
    char ch;

    printf("Enter an alphabet character: \n");
    // Using %c to read a single character
    scanf(" %c", &ch);

    switch (ch) {
        case 'a':
        case 'A':
        case 'e':
        case 'E':
        case 'i':
        case 'I':
        case 'o':
        case 'O':
        case 'u':
        case 'U':
            printf("%c is a Vowel.\n", ch);
            break;
        default:
            printf("%c is a Consonant.\n", ch);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

This illustrates switch fall-through.

• The cases for both lowercase and uppercase vowels are stacked without a break in between them. For example, if the input is 'a', the code executes the block under 'U' (which is the first block with a break).
• This structure allows multiple case labels to execute the same block of code, efficiently grouping all 10 vowels.
• The default case handles any other character, which we assume here to be a consonant (though you could add logic to check it’s actually a letter first).

#include <stdio.h>

int main() {
    int N = 5, i;
    long long factorial = 1; // Start at 1 for multiplication

    if (N < 0) {
        printf("Error: Factorial is not defined for negative numbers.\n");
    } else {
        // Calculate factorial
        for (i = 1; i <= N; i++) {
            factorial *= i; // Equivalent to: factorial = factorial * i;
        }
        printf("Factorial of %d is %lld.\n", N, factorial);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

Factorial is a product, so the accumulator (factorial) is initialized to 1.

• An initial if check handles the invalid case of a negative number.
• The for loop iterates from 1 up to N.
• The line factorial *= i; accumulates the product. If N is 5, the factorial variable changes like this: 1→1×2→2×3→6×4→24×5=120.
• The long long type is used for factorial because factorials grow very quickly and exceed the capacity of a standard int.

#include <stdio.h>

int main() {
    int choice;

    do {
        printf("\n--- Menu ---\n");
        printf("1. Greet\n");
        printf("2. Say Goodbye\n");
        printf("3. Exit\n");
        printf("Enter your choice (1-3): ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                printf("Hello! Welcome to the program.\n");
                break;
            case 2:
                printf("Goodbye! Have a nice day.\n");
                break;
            case 3:
                printf("Exiting program. Thank you!\n");
                break; // Required to exit switch, not do-while
            default:
                printf("Invalid choice. Please enter 1, 2, or 3.\n");
        }
    } while (choice != 3); // Loop continues UNTIL choice is 3

    return 0;
}Code language: C++ (cpp)

Explanation:

This combines control flow structures for interactive programs.

• do { ... } while (condition): The code inside the do block executes first. The condition (choice != 3) is checked after the first run.
• The switch statement inside the loop handles the different menu options.
• The loop continues as long as choice is not equal to 3. Once the user enters 3, the switch handles the exit message, and the while condition becomes false, terminating the entire loop and ending the program.

#include <stdio.h>

int main() {
    int num = 12568, count = 0;

    // Handle the case where the input is 0 separately
    if (num == 0) {
        count = 1;
    }

    int temp = num; // Use a temporary variable to preserve the original number

    while (temp > 0) {
        temp = temp / 10;
        count++;
    }

    printf("The number of digits in %d is: %d\n", num, count);
    return 0;
}Code language: C++ (cpp)

Explanation:

This program uses a loop to repeatedly strip off the last digit of the number.

• temp = temp / 10: Because this is integer division in C, 123/10 results in 12, 12/10 results in 1, and 1/10 results in 0.
• count++: The counter increases once for every digit removed.
• The loop continues as long as temp > 0, ensuring that every digit contributes one count before the number is fully reduced to 0.

#include <stdio.h>

int main() {
    int num = 1234, reversed = 0, remainder;

    int originalNum = num; // Keep the original number for output

    while (num != 0) {
        remainder = num % 10;         // 1. Get the last digit
        reversed = reversed * 10 + remainder; // 2. Append it to reversed number
        num /= 10;                    // 3. Remove the last digit
    }

    printf("Original number: %d\n", originalNum);
    printf("Reversed number: %d\n", reversed);
    return 0;
}Code language: C++ (cpp)

Explanation:

This is a classic loop-based digit manipulation problem. The while loop continues until the original number is reduced to 0.

• Extraction: remainder = num % 10 isolates the right-most digit.
• Construction: reversed = reversed * 10 + remainder is the key. Multiplying reversed by 10 shifts all existing digits one place to the left, making room to add the new remainder in the units place.
• Reduction: num /= 10 (integer division) removes the digit that was just processed.

#include <stdio.h>

int main() {
    int num = 121, reversed = 0, originalNum;

    originalNum = num; // Store the original value

    // Logic to reverse the number
    while (num > 0) {
        reversed = reversed * 10 + (num % 10);
        num /= 10;
    }

    // Control flow check
    if (originalNum == reversed) {
        printf("%d is a PALINDROME number.\n", originalNum);
    } else {
        printf("%d is NOT a palindrome number.\n", originalNum);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

1. The original number is stored in originalNum before the loop modifies the num variable.
2. The while loop calculates the reversed version of the number (exactly as in Exercise 12).
3. Finally, the if-else statement acts as the control flow decision: if originalNum equals reversed, the condition is true, and it’s a palindrome; otherwise, it is not

#include <stdio.h>

int main() {
    int N = 20, i;

    printf("Odd numbers from 1 to %d:\n", N);

    for (i = 1; i <= N; i++) {
        // Control flow check for even numbers
        if (i % 2 == 0) {
            continue; // Skips the rest of the loop body for even numbers
        }

        // This line only executes if 'i' is ODD
        printf("%d ", i);
    }
    printf("\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

The continue keyword alters control flow within a loop by skipping the current iteration and immediately moving to the next one (i.e., the loop update expression).

• The loop iterates through all numbers.
• When an even number is encountered (i % 2 == 0), continue is executed. This causes the program to jump directly to i++, skipping the printf statement for that even number.
• The printf statement is only reached when i is an odd number.

#include <stdio.h>

int main() {
    int base = 5, exponent = 3, i;
    long long result = 1; // Use long long for potentially large results

    // Control flow: Handle x^0 case
    if (exponent == 0) {
        result = 1;
    } else {
        // Loop runs 'exponent' number of times
        for (i = 1; i <= exponent; i++) {
            result *= base; // Equivalent to: result = result * base;
        }
    }

    printf("%d^%d = %lld\n", base, exponent, result);

    return 0;
}Code language: C++ (cpp)

Explanation:

This solution uses a loop to perform repeated multiplication.

• Initialization: result starts at 1 because multiplying x by 1 y times gives x^y.
• if-else Control: The program first checks for the edge case where the exponent is 0.
• Loop: The for loop runs exactly exponent times. In each iteration, the base is multiplied into the result. For example, 23:
  • i=1: result becomes 1×2=2
  • i=2: result becomes 2×2=4
  • i=3: result becomes 4×2=8
• long long is used for result to prevent overflow, as powers can grow very large very quickly.

#include <stdio.h>

int main() {
    int rows = 4, cols = 4, i, j;

    // Outer loop for rows
    for (i = 1; i <= rows; i++) {
        // Inner loop for columns (prints stars in a single row)
        for (j = 1; j <= cols; j++) {
            printf("*");
        }
        printf("\n"); // Move to the next line after a row is complete
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

Nested loops are essential for 2D patterns.

• Outer loop (i): Iterates R times, representing each row.
• Inner loop (j): Iterates C times. In each iteration, it prints one * without a newline, building a single row horizontally.
• Newline: printf("\n"); is placed outside the inner loop but inside the outer loop. This ensures that after a complete row of C stars is printed, the cursor moves to the beginning of the next line.

#include <stdio.h>

int main() {
    int N = 3, i, j;

    // Outer loop controls rows (1 to N)
    for (i = 1; i <= N; i++) {
        // Inner loop controls columns (prints 1 up to current row number i)
        for (j = 1; j <= i; j++) {
            printf("%d ", j); // Print the column index 'j'
        }
        printf("\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

The key here is setting the correct termination condition for the inner loop.

• Outer Loop Variable (i): Determines how many numbers will be printed in the current row.
• Inner Loop Condition: j <= i. This ensures that the inner loop runs i times. For example, when i=3, the inner loop runs for j=1,2,3.
• Output: The inner loop prints the counter j itself, resulting in the sequence 1,1 2,1 2 3, and so on

#include <stdio.h>

int main() {
    int N = 3, i, j;

    // Outer loop starts at N and decrements
    for (i = N; i >= 1; i--) {
        // Inner loop prints stars equal to the current row index 'i'
        for (j = 1; j <= i; j++) {
            printf("*");
        }
        printf("\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

This demonstrates reversing the iteration of the outer loop.

• Outer Loop Initialization: i = N. Starting at N ensures the first row has the maximum length.
• Outer Loop Update: i--. The row count decreases in each iteration.
• Inner Loop Condition: j <= i. Since i decreases from N to 1, the number of stars printed in the inner loop also decreases from N to 1, creating the inverted triangle.

#include <stdio.h>
int main() {
    for (int n = 1; n <= 10; n++) {
        printf("Table of %d\n", n);
        for (int i = 1; i <= 10; i++) {
            int product = n*i;
            printf("%2d x %2d = %3d\n", n, i, product);
        }
        printf("\n");
    }
    return 0;
}Code language: C++ (cpp)

Explanation:

• Use an outer loop to choose the base number n from 1 to 10. Inside it, run an inner loop i = 1..10 and print n x i = n*i, using fixed field widths to keep columns aligned.
• After finishing a table for one n, print a blank line for readability. The two dimensions (base and multiplier) naturally map to nested loops.

#include <stdio.h>

int main() {
    int N, num, i;
    int smallest, largest;

    printf("How many numbers will you enter (N)? \n");
    scanf("%d", &N);

    printf("Enter the numbers:\n");

    for (i = 1; i <= N; i++) {
        scanf("%d", &num);

        // Initialize smallest and largest with the very first number
        if (i == 1) {
            smallest = num;
            largest = num;
            continue; // Skip the rest of the checks for the first number
        }

        // Update smallest and largest using control flow
        if (num < smallest) {
            smallest = num;
        }
        if (num > largest) {
            largest = num;
        }
    }

    printf("\nLargest number entered: %d\n", largest);
    printf("Smallest number entered: %d\n", smallest);

    return 0;
}Code language: C++ (cpp)

Explanation:

• Initialization: The if (i == 1) block ensures that smallest and largest are correctly set to the value of the first input number. The continue jumps past the update checks for this first iteration.
• Loop Updates: Inside the loop, two separate if statements (not if-else) independently check if the current input num is smaller than the current smallest or larger than the current largest. If a number meets the condition, the corresponding variable is updated.

#include <stdio.h>
#include <stdbool.h> // For using the boolean type
#include <math.h>    // For the sqrt() function

int main() {
    int N = 31, i;
    bool isPrime = true;

    // 0 and 1 are not prime numbers
    if (N <= 1) {
        isPrime = false;
    } else {
        // Loop from 2 up to the square root of N
        for (i = 2; i <= sqrt(N); i++) {
            if (N % i == 0) {
                isPrime = false;
                break; // Optimization: Found a factor, no need to check further
            }
        }
    }

    if (isPrime) {
        printf("%d is a PRIME number.\n", N);
    } else {
        printf("%d is NOT a prime number.\n", N);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• Initialization: A bool flag isPrime is set to true (optimistically assuming the number is prime).
• Optimization: The for loop checks only up to square root of N​ because if N has a factor greater than square root of N​, it must also have a factor smaller than square root of N​.
• break: If a divisor is found (N % i == 0), isPrime is set to false, and the break keyword immediately terminates the for loop, saving processing time.

#include <stdio.h>
#include <stdbool.h>
#include <math.h>

int main() {
    int start = 10, end = 20, num, i;
    bool isPrime;

    printf("Prime numbers between %d and %d are:\n", start, end);

    // Outer loop iterates through every number in the range
    for (num = start; num <= end; num++) {
        if (num <= 1) {
            continue; // Skip 0 and 1
        }

        isPrime = true;
        // Inner loop checks primality of 'num'
        for (i = 2; i <= sqrt(num); i++) {
            if (num % i == 0) {
                isPrime = false;
                break; // Found a factor, not prime
            }
        }

        if (isPrime) {
            printf("%d ", num);
        }
    }
    printf("\n");
    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise demonstrates use of nested loops and the continue keyword.

• Outer Loop: The for (num = start; ...) loop ensures every number in the specified range is tested.
• continue: if (num <= 1) { continue; } is used to skip 0 and 1 and immediately jump to the next iteration of the outer loop, preventing unnecessary checks.
• Inner Logic: The inner loop implements the same primality test as Exercise 15. If isPrime remains true after the inner loop finishes, the number is printed.

#include <stdio.h>

int main() {
    int num1 = 10, num2 = 30, i, gcd = 1;

    // Loop runs up to the smaller of the two numbers
    int limit = (num1 < num2) ? num1 : num2;

    for (i = 1; i <= limit; i++) {
        // Check if i divides both num1 AND num2 evenly
        if (num1 % i == 0 && num2 % i == 0) {
            gcd = i; // Store this factor; it will be the greatest one found
        }
    }

    printf("GCD of %d and %d is: %d\n", num1, num2, gcd);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The loop iterates through all possible common factors starting from 1.
• Conditional Check: if (num1 % i == 0 && num2 % i == 0) ensures that i divides both numbers evenly.
• Accumulation: gcd = i updates the gcd variable every time a common factor is found. Because the loop iterates in increasing order, the last value stored in gcd will necessarily be the largest (Greatest) Common Divisor.

#include <stdio.h>

int main() {
    int num = 153, originalNum, remainder, sum = 0;

    originalNum = num; // Store the original value

    while (num > 0) {
        remainder = num % 10; // Extract the last digit

        // Add the cube of the digit to the sum
        // remainder * remainder * remainder is the cube
        sum = sum + (remainder * remainder * remainder);

        num /= 10; // Remove the last digit
    }

    // Control flow check
    if (originalNum == sum) {
        printf("%d is an ARMSTRONG number.\n", originalNum);
    } else {
        printf("%d is NOT an Armstrong number.\n", originalNum);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

This program extends the digit-by-digit processing loop by introducing the cube calculation.

• Digit Extraction Loop: The while loop extracts digits using the modulo operator (% 10) and removes them using integer division (/ 10).
• Summation: Inside the loop, sum acts as the accumulator, adding the cube of the remainder (remainder * remainder * remainder) in each step.
• Final Check: After the loop finishes and all digits have been processed, the if-else statement compares the final sum with the preserved originalNum to determine if it is an Armstrong number.

#include <stdio.h>

int main() {
    int N = 3, i, j;

    for (i = 1; i <= N; i++) {
        // 1. Loop to print leading spaces
        for (j = 1; j <= N - i; j++) {
            printf(" ");
        }

        // 2. Loop to print stars
        // Number of stars is always 2*i - 1
        for (j = 1; j <= 2 * i - 1; j++) {
            printf("*");
        }

        printf("\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• Outer Loop (i): Controls the row number (from 1 to N).
• First Inner Loop: Prints N - i spaces. As i increases (we move down the pyramid), the number of leading spaces decreases, shifting the center outward.
• Second Inner Loop: Prints 2 * i - 1 stars. The number of stars increases by 2 in each row (e.g., 1,3,5,7,…), which is the characteristic of a full pyramid.

#include <stdio.h>

int main() {
    int n = 9;
    if (n <= 0) { return 0; }
    long long a = 0, b = 1;
    for (int i = 1; i <= n; i++) {
        printf("%lld ", a);
        long long c = a + b;
        a = b;
        b = c;
    }
    printf("\n");
    return 0;
}Code language: C++ (cpp)

Explanation:

We iterate n times, always printing the current term (a) before advancing. The rolling update keeps only two previous terms in memory, making this approach simple and efficient. Using a 64-bit type delays overflow for moderate n.

#include <stdio.h>

int main() {
    int n = 10;
    if (n <= 0) { printf("Enter a positive integer.\n"); return 0; }

    for (int i = 1; i <= n; i++) {
        if (n % i == 0) printf("%d ", i);
    }
    printf("\n");
    return 0;
}Code language: C++ (cpp)

Explanation:

We check each candidate from 1 through n for exact divisibility. Whenever the remainder is zero, that candidate is a factor and gets printed. This O(n) approach is straightforward for teaching loops; later, you can optimize using i*i <= n and printing factor pairs.