Iterative constructs in Java

A. The Four Essential Components of Any Loop:

1. 1. Initialization Expression: Sets the starting value of the loop control variable (e.g., int i = 1;). Executes once at the very beginning.
2. 2. Test Expression (Condition): A boolean condition evaluated before (or after) each iteration. If true, the loop body executes; if false, the loop terminates.
3. 3. Loop Body: The set of statements executed repeatedly during each iteration.
4. 4. Update Expression: Modifies (increments/decrements) the loop control variable after each iteration (e.g., i++), steering the loop towards termination.

B. Entry-Controlled vs Exit-Controlled Loops:

A. The `for` Loop (Definite Iteration):

for (initialization; test_condition; update_expression) {
    // Loop body statements
}

Execution Order: 1. Initialization → 2. Condition check → 3. Body execution → 4. Update expression → 5. Repeat from Step 2.

B. The `while` Loop (Indefinite Pre-Test):

initialization;
while (test_condition) {
    // Loop body statements
    update_expression;
}

C. The `do-while` Loop (Post-Test):

initialization;
do {
    // Loop body statements
    update_expression;
} while (test_condition); // Note the compulsory semicolon!

D. Loop Variations & Traps:

• Infinite Loop: for(;;) { } or while(true) { } (Never terminates unless break is triggered).
• The Null / Empty Loop Trap: Putting an accidental semicolon at the end of a loop header creates a loop with an empty body:

  int i;
  for (i = 1; i <= 5; i++); // Semicolon here isolates the loop!
  System.out.println(i);    // Prints 6 (prints once after loop finishes)!

A. The `break` Statement:

Forces the immediate and complete termination of the enclosing loop. Control jumps directly to the first statement outside the loop block.

for (int i = 1; i <= 10; i++) {
    if (i == 5) break; // Exits loop completely when i reaches 5
    System.out.print(i + " ");
} // Output: 1 2 3 4

B. The `continue` Statement:

Skips the remaining statements of the current iteration and transfers control immediately to the next iteration (jumping directly to the update expression in a for loop, or to the condition in a while loop).

for (int i = 1; i <= 5; i++) {
    if (i == 3) continue; // Skips printing 3
    System.out.print(i + " ");
} // Output: 1 2 4 5

A. The Universal Digit Extraction Algorithm:

To process individual digits of an integer $N$ from right to left:

int n = 153;
while (n > 0) {
    int digit = n % 10; // Extract the rightmost (last) digit
    // Process the extracted digit (sum, reverse, count, etc.)
    n = n / 10;         // Strip/remove the rightmost digit
}

B. Trace Table for Digit Extraction ($N = 153$):

Complete Reference Algorithms:

A. Armstrong Number Verification:

import java.util.Scanner;

public class ArmstrongCheck {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter an integer: ");
        int num = in.nextInt();
        int temp = num;
        int sumOfCubes = 0;

        while (temp > 0) {
            int digit = temp % 10;
            sumOfCubes += (digit * digit * digit);
            temp /= 10;
        }

        if (sumOfCubes == num) {
            System.out.println(num + " is an Armstrong Number.");
        } else {
            System.out.println(num + " is NOT an Armstrong Number.");
        }
    }
}

B. Generating the Fibonacci Series (0, 1, 1, 2, 3, 5, 8, 13...):

public class FibonacciDemo {
    public static void main(String[] args) {
        int n = 10; // Number of terms
        int first = 0, second = 1;
        System.out.print("Fibonacci Series: " + first + " " + second + " ");
        for (int i = 3; i <= n; i++) {
            int next = first + second;
            System.out.print(next + " ");
            first = second;
            second = next;
        }
        System.out.println();
    }
}

A. Palindrome Number Checker:

import java.util.Scanner;

public class PalindromeCheck {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter an integer: ");
        int n = in.nextInt();
        int original = n;
        int reversed = 0;

        while (n > 0) {
            int digit = n % 10;
            reversed = reversed * 10 + digit;
            n /= 10;
        }

        if (reversed == original) {
            System.out.println(original + " is a Palindrome Number.");
        } else {
            System.out.println(original + " is NOT a Palindrome Number.");
        }
    }
}

B. Special (Krishnamurthy) Number Checker (145 = 1! + 4! + 5!):

public class SpecialNumberCheck {
    public static void main(String[] args) {
        int n = 145;
        int temp = n;
        int sumOfFactorials = 0;

        while (temp > 0) {
            int digit = temp % 10;
            // Compute factorial of extracted digit
            int fact = 1;
            for (int i = 1; i <= digit; i++) {
                fact *= i;
            }
            sumOfFactorials += fact;
            temp /= 10;
        }

        if (sumOfFactorials == n) {
            System.out.println(n + " is a Special (Krishnamurthy) Number.");
        } else {
            System.out.println(n + " is NOT a Special Number.");
        }
    }
}

A. Calculating HCF/GCD and LCM using while loop:

import java.util.Scanner;

public class HcfLcmDemo {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter two positive integers: ");
        int a = in.nextInt();
        int b = in.nextInt();

        int num1 = a, num2 = b;
        // Euclidean remainder loop
        while (num2 != 0) {
            int remainder = num1 % num2;
            num1 = num2;
            num2 = remainder;
        }
        int hcf = num1;
        int lcm = (a * b) / hcf; // Mathematical relationship: Product = HCF * LCM

        System.out.println("Highest Common Factor (HCF) = " + hcf);
        System.out.println("Lowest Common Multiple (LCM) = " + lcm);
    }
}

A. Neon Number Program (9² = 81 → 8 + 1 = 9):

public class NeonNumber {
    public static void main(String[] args) {
        int n = 9;
        int sq = n * n;
        int sum = 0;
        while (sq > 0) {
            sum += sq % 10;
            sq /= 10;
        }
        if (sum == n) System.out.println(n + " is a Neon Number.");
        else System.out.println(n + " is NOT a Neon Number.");
    }
}

A. What is an Automorphic Number?

An Automorphic Number is a number whose square ends in the same digits as the number itself. For example: $5^2 = 25$ (ends in 5), $6^2 = 36$ (ends in 6), $25^2 = 625$ (ends in 25), and $76^2 = 5776$ (ends in 76).

int n = 25;
int sq = n * n;
int temp = n;
int divisor = 1;
// Find divisor (10, 100, etc.) matching digit count of n
while (temp > 0) {
    divisor *= 10;
    temp /= 10;
}
if (sq % divisor == n) {
    System.out.println(n + " is an Automorphic Number.");
} else {
    System.out.println(n + " is NOT an Automorphic Number.");
}

A. Prime Number Verification Efficiency:

Checking divisors from 2 up to $N-1$ takes $O(N)$ operations. A superior mathematical optimization checks divisors only up to $\sqrt{N}$ (i * i <= N), reducing iterations from 1,000,000 down to just 1,000 checks for $N = 1,000,000$, resulting in a 1,000-fold performance acceleration!

Factorial values grow with extreme exponential speed. While a standard 32-bit int can hold factorials up to 12! (479,001,600), computing 13! overflows an int! Therefore, always declare the factorial accumulator as a 64-bit long variable when calculating factorials up to 20!.