Java Number Programs - Learning with Nitheesh

Hello, World!

The traditional first program in any programming language that demonstrates basic syntax.

Add Two Numbers

Learn how to perform basic arithmetic operations and variable assignment in Java.

Find Even or Odd

Understand conditional statements and the modulus operator in Java.

Find the Largest Number

A program to compare two numbers and find the larger one using conditional logic.

Simple Interest Calculation

A program to calculate simple interest using the formula SI = (P × R × T) / 100.

Check Leap Year

A program to check whether a given year is a leap year.

Swap Without Third Variable

A program to swap two numbers without using a third variable.

Factorial of a Number

A program to find the factorial of a number.

Reverse a Number

A program to reverse a given number.

Sum of Digits

A program to find the sum of digits of a number.

Check Prime Number

A program to check whether a number is prime or not.

Multiplication Table

A program to print the multiplication table of a given number.

Largest of Three Numbers

A program to find the largest of three numbers.

Palindrome Number

A program to check whether a number is a palindrome.

Fibonacci Series

A program to print the Fibonacci series up to N terms.

Armstrong Number

A program to check whether a number is an Armstrong number.

Perfect Number

A program to check whether a number is a Perfect number.

Strong Number

A program to check if a number is a Strong number.

Automorphic Number

A program to check if a number is Automorphic (its square ends with the number itself).

Harshad Number

A program to check if a number is a Harshad number (divisible by the sum of its digits).

Duck Number

A program to check whether a number is a Duck number (contains at least one zero but not at the beginning).

Neon Number

A program to check whether a number is a Neon number (sum of digits of square of the number equals the number).

Kaprekar Number

A program to check whether a number is a Kaprekar number (sum of parts of its square equals the number).

Magic Number

A program to check if a number is a Magic number (repeated sum of digits results in 1).

HCF (GCD)

A program to find the HCF (GCD) of two numbers.

Automorphic Number

Check whether a number is an Automorphic number.

Write a program to check whether a number is an Automorphic number.

Input

Output

Automorphic Number

public class AutomorphicNumber {
                public static void main(String[] args) {
                    int num = 76;
                    int square = num * num;

                    String numStr = String.valueOf(num);
                    String squareStr = String.valueOf(square);

                    if (squareStr.endsWith(numStr)) {
                        System.out.println("Automorphic Number");
                    } else {
                        System.out.println("Not an Automorphic Number");
                    }
                }
            }

Explanation:

Calculate the square of the number.
Convert both the number and its square to strings.
Check if the square ends with the number using endsWith() method.

Peterson Number

Check whether a number is a Peterson number.

Write a program to check whether a number is a Peterson number.

Input

145

Output

Peterson Number

public class PetersonNumber {
                    public static void main(String[] args) {
                        int num = 145;
                        int temp = num;
                        int sum = 0;

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

                        if (sum == num) {
                            System.out.println("Peterson Number");
                        } else {
                            System.out.println("Not a Peterson Number");
                        }
                    }

                    static int factorial(int n) {
                        int fact = 1;
                        for (int i = 2; i <= n; i++) {
                            fact *= i;
                        }
                        return fact;
                    }
                }

Explanation:

Extract each digit of the number using modulus and division.
Compute the factorial of each digit.
Sum the factorials and compare the result with the original number.
If equal, it's a Peterson number.

Sunny Number

Check whether a number is a Sunny number.

Write a program to check whether a number is a Sunny number.

Input

Output

Sunny Number

public class SunnyNumber {
                  public static void main(String[] args) {
                      int num = 80;
                      int nextNum = num + 1;
                      double sqrt = Math.sqrt(nextNum);

                      if (sqrt == (int) sqrt) {
                          System.out.println("Sunny Number");
                      } else {
                          System.out.println("Not a Sunny Number");
                      }
                  }
              }

Explanation:

Add 1 to the number.
Check if the square root of the result is an integer.
If it is, the number is a Sunny number.

Fascinating Number

Check whether a number is a Fascinating number.

Write a program to check whether a number is a Fascinating number.

Input

192

Output

Fascinating Number

public class FascinatingNumber {
                public static void main(String[] args) {
                    int num = 192;

                    if (num < 100) {
                        System.out.println("Not a Fascinating Number");
                        return;
                    }

                    String result = "" + num + (num * 2) + (num * 3);

                    boolean isFascinating = result.length() == 9;
                    for (char c = '1'; c <= '9' && isFascinating; c++) {
                        if (result.indexOf(c) == -1 || result.replace(String.valueOf(c), "").length() != result.length() - 1) {
                            isFascinating = false;
                        }
                    }

                    if (isFascinating) {
                        System.out.println("Fascinating Number");
                    } else {
                        System.out.println("Not a Fascinating Number");
                    }
                }
            }

Explanation:

Concatenate the number with its multiples by 2 and 3.
Check if the resulting string has all digits from 1 to 9 exactly once.
If true, the number is Fascinating.

Keith Number

Check whether a number is a Keith number.

Write a program to check whether a number is a Keith number.

Input

197

Output

Keith Number

import java.util.ArrayList;

    public class KeithNumber {
        public static void main(String[] args) {
            int num = 197;
            int temp = num;
            ArrayList<Integer> terms = new ArrayList<>();

            // Extract digits and add to list
            while (temp > 0) {
                terms.add(0, temp % 10);
                temp /= 10;
            }

            int n = terms.size();
            int sum = 0, i = n;

            while (sum < num) {
                sum = 0;
                for (int j = i - n; j < i; j++) {
                    sum += terms.get(j);
                }
                terms.add(sum);
                i++;
            }

            if (sum == num) {
                System.out.println("Keith Number");
            } else {
                System.out.println("Not a Keith Number");
            }
        }
    }

Explanation:

Start with the digits of the number.
Generate the sequence by summing the previous n digits.
If the number appears in the sequence, it is a Keith number.

Neon Number

Check whether a number is a Neon number.

Write a program to check whether a number is a Neon number.

Input

Output

Neon Number

public class NeonNumber {
        public static void main(String[] args) {
            int num = 9;
            int square = num * num;
            int sum = 0;

            while (square > 0) {
                sum += square % 10;
                square /= 10;
            }

            if (sum == num) {
                System.out.println("Neon Number");
            } else {
                System.out.println("Not a Neon Number");
            }
        }
    }

Explanation:

Square the number.
Sum the digits of the square.
If the sum equals the original number, it is a Neon number.

Spy Number

Check whether a number is a Spy number.

Write a program to check whether a number is a Spy number.

Input

123

Output

Spy Number

public class SpyNumber {
        public static void main(String[] args) {
            int num = 123;
            int sum = 0, product = 1;
            int temp = num;

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

            if (sum == product) {
                System.out.println("Spy Number");
            } else {
                System.out.println("Not a Spy Number");
            }
        }
    }

Explanation:

Extract each digit of the number.
Calculate the sum and the product of the digits.
If both are equal, the number is a Spy number.

ATM Program

Simulate basic ATM operations using a menu-driven approach.

Write a Java program to simulate basic ATM operations such as withdraw, deposit, and check balance using a menu-driven approach.

Input

1 (Check Balance), 2 (Withdraw), 3 (Deposit)

Output

Current Balance: 1000
    Withdrawn: 500
    New Balance: 500

import java.util.Scanner;

    public class ATMProgram {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int balance = 1000;

            while (true) {
                System.out.println("\nATM Menu:");
                System.out.println("1. Check Balance");
                System.out.println("2. Withdraw");
                System.out.println("3. Deposit");
                System.out.println("4. Exit");
                System.out.print("Choose an option: ");
                int choice = scanner.nextInt();

                switch (choice) {
                    case 1:
                        System.out.println("Current Balance: " + balance);
                        break;
                    case 2:
                        System.out.print("Enter amount to withdraw: ");
                        int withdraw = scanner.nextInt();
                        if (withdraw > balance) {
                            System.out.println("Insufficient Balance.");
                        } else {
                            balance -= withdraw;
                            System.out.println("Withdrawn: " + withdraw);
                            System.out.println("New Balance: " + balance);
                        }
                        break;
                    case 3:
                        System.out.print("Enter amount to deposit: ");
                        int deposit = scanner.nextInt();
                        balance += deposit;
                        System.out.println("Deposited: " + deposit);
                        System.out.println("New Balance: " + balance);
                        break;
                    case 4:
                        System.out.println("Thank you for using the ATM.");
                        return;
                    default:
                        System.out.println("Invalid option.");
                }
            }
        }
    }

Explanation:

A menu is shown to the user to perform operations: check balance, withdraw, deposit, or exit.
Based on user input, the corresponding action is performed on the balance.
Validations are included for insufficient balance and invalid choices.

Autobiographical Number

Check whether a number is an Autobiographical number.

Write a program to check if a number is an Autobiographical number. (Each digit describes how many times digits 0-9 occur in the number.)

Input

1210

Output

Autobiographical Number

public class AutobiographicalNumber {
        public static void main(String[] args) {
            String num = "1210";
            int[] count = new int[10];

            // Count digits
            for (int i = 0; i < num.length(); i++) {
                int digit = num.charAt(i) - '0';
                count[digit]++;
            }

            // Check if each digit matches the frequency
            boolean isAutoBio = true;
            for (int i = 0; i < num.length(); i++) {
                int expected = num.charAt(i) - '0';
                if (count[i] != expected) {
                    isAutoBio = false;
                    break;
                }
            }

            if (isAutoBio) {
                System.out.println("Autobiographical Number");
            } else {
                System.out.println("Not an Autobiographical Number");
            }
        }
    }

Explanation:

Each index in the number represents how many times that index (digit) appears in the entire number.
We count the occurrence of each digit and compare with the digit at corresponding index.
If all digits match this rule, it's an Autobiographical number.

Emirp Number

Check whether a number is an Emirp number.

Write a program to check whether a number is an Emirp number or not. (A number is Emirp if it is prime and its reverse is also a different prime.)

Input

Output

Emirp Number

public class EmirpNumber {
        public static void main(String[] args) {
            int num = 13;
            
            if (isPrime(num)) {
                int rev = reverseNumber(num);
                if (rev != num && isPrime(rev)) {
                    System.out.println("Emirp Number");
                } else {
                    System.out.println("Not an Emirp Number");
                }
            } else {
                System.out.println("Not an Emirp Number");
            }
        }

        public static boolean isPrime(int n) {
            if (n <= 1) return false;
            for (int i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0) return false;
            }
            return true;
        }

        public static int reverseNumber(int n) {
            int rev = 0;
            while (n != 0) {
                rev = rev * 10 + n % 10;
                n /= 10;
            }
            return rev;
        }
    }

Explanation:

Check if the number is prime.
Find the reverse of the number.
Check if the reverse is a different prime number.
If all conditions are true, it is an Emirp number.

Sphenic Number

Check whether a number is a Sphenic number.

Write a program to check whether a number is a Sphenic number or not. (A number is Sphenic if it is a product of three distinct prime numbers.)

Input

Output

Sphenic Number

public class SphenicNumber {
        public static void main(String[] args) {
            int num = 30;
            int count = 0;
            int product = 1;
            int temp = num;

            for (int i = 2; i <= temp && count <= 3; i++) {
                if (isPrime(i) && temp % i == 0) {
                    count++;
                    product *= i;
                    temp /= i;
                    while (temp % i == 0) {
                        temp /= i; // Remove duplicates of the prime factor
                    }
                }
            }

            if (count == 3 && product == num) {
                System.out.println("Sphenic Number");
            } else {
                System.out.println("Not a Sphenic Number");
            }
        }

        public static boolean isPrime(int n) {
            if (n <= 1) return false;
            for (int i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0) return false;
            }
            return true;
        }
    }

Explanation:

Factorize the number and count distinct prime factors.
Check if the count of distinct prime factors is exactly 3 and their product equals the number.
If true, the number is Sphenic.

Buzz Number

Check whether a number is a Buzz number.

Write a program to check whether a number is a Buzz number or not. (A number is Buzz if it ends with 7 or is divisible by 7.)

Input

Output

Buzz Number

public class BuzzNumber {
        public static void main(String[] args) {
            int num = 27;
            if (num % 7 == 0 || num % 10 == 7) {
                System.out.println("Buzz Number");
            } else {
                System.out.println("Not a Buzz Number");
            }
        }
    }

Explanation:

Check if the number is divisible by 7 or ends with digit 7.
If yes, print "Buzz Number"; otherwise, print "Not a Buzz Number".

Evil Number

Check whether a number is an Evil number.

Write a program to check whether a number is an Evil number. (A number is Evil if it has an even number of 1’s in its binary representation.)

Input

Output

Evil Number

public class EvilNumber {
        public static void main(String[] args) {
            int num = 9;
            int countOnes = 0;
            int temp = num;

            while (temp > 0) {
                if ((temp & 1) == 1) {
                    countOnes++;
                }
                temp >>= 1;
            }

            if (countOnes % 2 == 0) {
                System.out.println("Evil Number");
            } else {
                System.out.println("Not an Evil Number");
            }
        }
    }

Explanation:

Convert the number to binary and count the number of 1's using bitwise operations.
If the count of 1's is even, it is an Evil Number.
Otherwise, it is not an Evil Number.

ISBN Number

Validate a 10-digit ISBN number.

Write a program to validate a 10-digit ISBN number.

Input

0306406152

Output

Valid ISBN Number

public class ISBNNumber {
        public static void main(String[] args) {
            String isbn = "0306406152";
            if (isValidISBN(isbn)) {
                System.out.println("Valid ISBN Number");
            } else {
                System.out.println("Invalid ISBN Number");
            }
        }

        public static boolean isValidISBN(String isbn) {
            if (isbn == null || isbn.length() != 10) {
                return false;
            }

            int sum = 0;
            for (int i = 0; i < 9; i++) {
                char ch = isbn.charAt(i);
                if (!Character.isDigit(ch)) {
                    return false;
                }
                sum += (ch - '0') * (10 - i);
            }

            char lastChar = isbn.charAt(9);
            if (lastChar != 'X' && !Character.isDigit(lastChar)) {
                return false;
            }

            sum += (lastChar == 'X') ? 10 : (lastChar - '0');

            return (sum % 11 == 0);
        }
    }

Explanation:

ISBN-10 validation multiplies each digit by its position weight (10 to 1) and sums them.
The last digit can be 'X' representing 10.
If the total sum is divisible by 11, the ISBN is valid.

Krishnamurthy Number

Check whether a number is a Krishnamurthy number.

Write a program to check whether a number is a Krishnamurthy number.

Input

145

Output

Krishnamurthy Number

public class KrishnamurthyNumber {
        public static void main(String[] args) {
            int num = 145;
            if (isKrishnamurthy(num)) {
                System.out.println("Krishnamurthy Number");
            } else {
                System.out.println("Not a Krishnamurthy Number");
            }
        }

        public static boolean isKrishnamurthy(int num) {
            int sum = 0;
            int temp = num;
            while (temp > 0) {
                int digit = temp % 10;
                sum += factorial(digit);
                temp /= 10;
            }
            return sum == num;
        }

        public static int factorial(int n) {
            int fact = 1;
            for (int i = 2; i <= n; i++) {
                fact *= i;
            }
            return fact;
        }
    }

Explanation:

Calculate the factorial of each digit of the number.
Sum all these factorials.
If the sum equals the original number, it is a Krishnamurthy number.

Bouncy Number

Check whether a number is a Bouncy number.

Write a program to check whether a number is a Bouncy number.

Input

155349

Output

Bouncy Number

public class BouncyNumber {
        public static void main(String[] args) {
            int num = 155349;
            if (isBouncy(num)) {
                System.out.println("Bouncy Number");
            } else {
                System.out.println("Not a Bouncy Number");
            }
        }

        public static boolean isBouncy(int num) {
            boolean increasing = false;
            boolean decreasing = false;
            int prevDigit = num % 10;
            num /= 10;

            while (num > 0) {
                int currDigit = num % 10;
                if (currDigit < prevDigit) {
                    increasing = true;
                } else if (currDigit > prevDigit) {
                    decreasing = true;
                }
                if (increasing && decreasing) {
                    return true; // Bouncy
                }
                prevDigit = currDigit;
                num /= 10;
            }
            return false; // Not Bouncy
        }
    }

Explanation:

Traverse digits from right to left.
Check if digits are increasing or decreasing.
If both increasing and decreasing patterns exist, the number is bouncy.

Mystery Number

Check whether a number is a Mystery number.

Write a program to check whether a number is a Mystery number. (A number is Mystery if it can be expressed as the sum of two numbers and their reverse.)

Input

121

Output

Mystery Number

public class MysteryNumber {
        public static void main(String[] args) {
            int num = 121;
            if (isMystery(num)) {
                System.out.println("Mystery Number");
            } else {
                System.out.println("Not a Mystery Number");
            }
        }

        // Returns reverse of a number
        public static int reverse(int n) {
            int rev = 0;
            while (n > 0) {
                rev = rev * 10 + n % 10;
                n /= 10;
            }
            return rev;
        }

        public static boolean isMystery(int num) {
            // Check for any pair (a,b) such that num = a + b + reverse(a) + reverse(b)
            for (int a = 0; a <= num; a++) {
                for (int b = 0; b <= num; b++) {
                    int sum = a + b + reverse(a) + reverse(b);
                    if (sum == num) {
                        return true;
                    }
                }
            }
            return false;
        }
    }

Explanation:

Check all possible pairs (a, b) such that sum of a, b, and their reverses equals the number.
If any such pair exists, the number is a Mystery number.

Smith Number

Check whether a number is a Smith number.

Write a program to check whether a number is a Smith number. (A number is Smith if it is a composite number for which the sum of digits equals the sum of digits of its prime factors.)

Input

666

Output

Smith Number

public class SmithNumber {
        public static void main(String[] args) {
            int num = 666;
            if (isSmithNumber(num)) {
                System.out.println("Smith Number");
            } else {
                System.out.println("Not a Smith Number");
            }
        }

        // Function to calculate sum of digits
        public static int sumOfDigits(int n) {
            int sum = 0;
            while (n > 0) {
                sum += n % 10;
                n /= 10;
            }
            return sum;
        }

        // Check if prime
        public static boolean isPrime(int n) {
            if (n <= 1) return false;
            for (int i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0) return false;
            }
            return true;
        }

        // Check Smith Number
        public static boolean isSmithNumber(int n) {
            if (isPrime(n)) return false; // Smith number must be composite

            int originalSum = sumOfDigits(n);
            int primeFactorSum = 0;
            int temp = n;

            // Find prime factors and sum their digits
            for (int i = 2; i <= temp; i++) {
                while (temp % i == 0) {
                    primeFactorSum += sumOfDigits(i);
                    temp /= i;
                }
            }

            return originalSum == primeFactorSum;
        }
    }

Explanation:

Calculate sum of digits of the number.
Find prime factors of the number and sum digits of those factors.
If both sums are equal and the number is composite, it is a Smith number.

Strontio Number

Check whether a number is a Strontio number.

Write a program to check whether a number is a Strontio number. (A number is Strontio if multiplying it by 2 results in a 4-digit number where the middle two digits are the same.)

Input

7694

Output

Strontio Number

public class StrontioNumber {
        public static void main(String[] args) {
            int num = 7694;
            if (isStrontio(num)) {
                System.out.println("Strontio Number");
            } else {
                System.out.println("Not a Strontio Number");
            }
        }

        public static boolean isStrontio(int n) {
            int product = n * 2;
            String prodStr = String.valueOf(product);

            // Check if product is a 4-digit number
            if (prodStr.length() != 4) {
                return false;
            }

            // Check if middle two digits are the same
            return prodStr.charAt(1) == prodStr.charAt(2);
        }
    }

Explanation:

Multiply the number by 2.
Check if the product is a 4-digit number.
Check if the middle two digits of the product are the same.
If yes, it is a Strontio number.

Xylem and Phloem Number

Check whether a number is a Xylem or Phloem number.

Write a program to check whether a number is a Xylem or Phloem number. (Xylem: sum of extreme digits = sum of mean digits; otherwise Phloem.)

Input

1234

Output

Phloem Number

public class XylemPhloemNumber {
        public static void main(String[] args) {
            int num = 1234;
            if (isXylem(num)) {
                System.out.println("Xylem Number");
            } else {
                System.out.println("Phloem Number");
            }
        }

        public static boolean isXylem(int n) {
            String s = String.valueOf(n);
            int length = s.length();

            int sumExtreme = s.charAt(0) - '0' + s.charAt(length - 1) - '0';

            int sumMean = 0;
            for (int i = 1; i < length - 1; i++) {
                sumMean += s.charAt(i) - '0';
            }

            return sumExtreme == sumMean;
        }
    }

Explanation:

Extract the digits as characters.
Sum the first and last digits (extreme digits).
Sum the digits between the first and last (mean digits).
If both sums are equal, the number is Xylem; otherwise, Phloem.

nth Prime Number

Find the nth prime number.

Write a program to find the nth prime number.

Input

Output

public class NthPrimeNumber {
        public static void main(String[] args) {
            int n = 10;
            System.out.println(n + "th prime number is: " + findNthPrime(n));
        }

        public static int findNthPrime(int n) {
            int count = 0;
            int num = 1;

            while (count < n) {
                num++;
                if (isPrime(num)) {
                    count++;
                }
            }
            return num;
        }

        public static boolean isPrime(int number) {
            if (number <= 1) return false;
            if (number == 2) return true;

            for (int i = 2; i <= Math.sqrt(number); i++) {
                if (number % i == 0) return false;
            }
            return true;
        }
    }

Explanation:

Iterate numbers starting from 2 upwards.
Check if the number is prime using the isPrime method.
Count primes until the nth prime is found.
Return the nth prime number.

Alternate Prime Numbers

Display alternate prime numbers up to a limit.

Write a program to display alternate prime numbers up to a limit.

Input

Output

2, 5, 11, 17

import java.util.ArrayList;

    public class AlternatePrimeNumbers {
        public static void main(String[] args) {
            int limit = 20;
            ArrayList primes = new ArrayList<>();

            for (int i = 2; i <= limit; i++) {
                if (isPrime(i)) {
                    primes.add(i);
                }
            }

            System.out.print("Alternate primes up to " + limit + ": ");
            for (int i = 0; i < primes.size(); i += 2) {
                System.out.print(primes.get(i));
                if (i + 2 < primes.size()) {
                    System.out.print(", ");
                }
            }
        }

        public static boolean isPrime(int num) {
            if (num <= 1) return false;
            if (num == 2) return true;

            for (int i = 2; i <= Math.sqrt(num); i++) {
                if (num % i == 0) return false;
            }
            return true;
        }
    }

Explanation:

Find all prime numbers up to the given limit.
Store them in a list.
Print every alternate prime starting from the first.

Square Root Without sqrt Method

Find the square root of a number without using the sqrt() method.

Write a program to find the square root of a number without using the sqrt() method.

Input

Output

public class SquareRootWithoutSqrt {
        public static void main(String[] args) {
            int num = 25;
            double sqrt = 0;
            double precision = 0.0001;

            // Using binary search to find square root
            double low = 0;
            double high = num;

            while ((high - low) > precision) {
                double mid = (low + high) / 2;
                if (mid * mid == num) {
                    sqrt = mid;
                    break;
                } else if (mid * mid < num) {
                    low = mid;
                    sqrt = mid;
                } else {
                    high = mid;
                }
            }

            System.out.printf("Square root of %d is %.4f%n", num, sqrt);
        }
    }

Explanation:

We use binary search between 0 and the number to approximate the square root.
Check the mid value’s square and adjust the search space accordingly.
Stop when the difference between low and high is within the desired precision.

Swap Two Numbers Using Bitwise Operator

Swap two numbers using the bitwise XOR operator.

Write a program to swap two numbers using bitwise XOR operator.

Input

a = 5, b = 10

Output

a = 10, b = 5

public class SwapUsingBitwiseXOR {
        public static void main(String[] args) {
            int a = 5, b = 10;

            a = a ^ b;  // Step 1
            b = a ^ b;  // Step 2
            a = a ^ b;  // Step 3

            System.out.println("a = " + a + ", b = " + b);
        }
    }

Explanation:

The XOR operator (^) swaps values without using a temporary variable.
Step 1 stores combined information in 'a'.
Step 2 extracts original 'a' into 'b'.
Step 3 extracts original 'b' into 'a'.

GCD of Two Numbers

Find the Greatest Common Divisor (GCD) of two numbers.

Write a program to find the GCD of two numbers.

Input

54, 24

Output

GCD: 6

public class GCDOfTwoNumbers {
        public static void main(String[] args) {
            int a = 54, b = 24;
            int gcd = findGCD(a, b);
            System.out.println("GCD: " + gcd);
        }

        public static int findGCD(int a, int b) {
            while (b != 0) {
                int temp = b;
                b = a % b;
                a = temp;
            }
            return a;
        }
    }

Explanation:

Uses the Euclidean algorithm to compute GCD.
Repeatedly replaces the larger number by its remainder when divided by the smaller number.
When the remainder becomes zero, the other number is the GCD.

Largest of Three Numbers

Find the largest among three numbers.

Write a program to find the largest of three numbers.

Input

10, 25, 15

Output

Largest: 25

public class LargestOfThree {
        public static void main(String[] args) {
            int a = 10, b = 25, c = 15;
            int largest = a;

            if (b > largest) {
                largest = b;
            }
            if (c > largest) {
                largest = c;
            }

            System.out.println("Largest: " + largest);
        }
    }

Explanation:

Initially assume the first number is largest.
Compare second and third numbers with the current largest and update accordingly.
Print the largest number.

Smallest of Three Numbers Using Ternary Operator

Find the smallest among three numbers using ternary operator.

Write a program to find the smallest of three numbers using the ternary operator.

Input

10, 25, 5

Output

Smallest: 5

public class SmallestOfThreeTernary {
        public static void main(String[] args) {
            int a = 10, b = 25, c = 5;

            int smallest = (a < b) ? ((a < c) ? a : c) : ((b < c) ? b : c);

            System.out.println("Smallest: " + smallest);
        }
    }

Explanation:

Use nested ternary operators to compare the three numbers.
First compare a and b; then compare the smaller of those with c.
Print the smallest number.

Check if Number is Positive or Negative

Check whether a given number is positive, negative, or zero.

Write a program to check whether a given number is positive, negative or zero.

Input

-8

Output

Negative Number

public class CheckPositiveNegative {
        public static void main(String[] args) {
            int num = -8;

            if (num > 0) {
                System.out.println("Positive Number");
            } else if (num < 0) {
                System.out.println("Negative Number");
            } else {
                System.out.println("Zero");
            }
        }
    }

Explanation:

Use if-else statements to check the sign of the number.
If number is greater than zero, print "Positive Number".
If less than zero, print "Negative Number".
If zero, print "Zero".

Perfect Square Check

Check whether a number is a perfect square.

Write a program to check whether a number is a perfect square.

Input

Output

Perfect Square

public class PerfectSquareCheck {
        public static void main(String[] args) {
            int num = 49;
            int sqrt = (int) Math.sqrt(num);

            if (sqrt * sqrt == num) {
                System.out.println("Perfect Square");
            } else {
                System.out.println("Not a Perfect Square");
            }
        }
    }

Explanation:

Calculate the integer square root of the number.
Check if the square of this integer equals the original number.
If equal, it is a perfect square; otherwise, it is not.

Even Numbers From 1 to 100

Display even numbers from 1 to 100.

Write a program to display even numbers from 1 to 100.

Input

1 to 100

Output

2, 4, 6, 8, ..., 100

public class EvenNumbers {
        public static void main(String[] args) {
            for (int i = 2; i <= 100; i += 2) {
                System.out.print(i);
                if (i < 100) {
                    System.out.print(", ");
                }
            }
        }
    }

Explanation:

Use a for loop starting from 2 to 100 incremented by 2.
Print each even number, separated by commas.

Odd Numbers From 1 to 100

Display odd numbers from 1 to 100.

Write a program to display odd numbers from 1 to 100.

Input

1 to 100

Output

1, 3, 5, 7, ..., 99

public class OddNumbers {
        public static void main(String[] args) {
            for (int i = 1; i <= 100; i += 2) {
                System.out.print(i);
                if (i < 99) {
                    System.out.print(", ");
                }
            }
        }
    }

Explanation:

Use a for loop starting from 1 to 100 incremented by 2.
Print each odd number separated by commas.

Sum of Natural Numbers

Find the sum of the first n natural numbers.

Write a program to find the sum of the first n natural numbers.

Input

Output

Sum: 55

public class SumOfNaturalNumbers {
        public static void main(String[] args) {
            int n = 10; // Number of natural numbers to sum
            int sum = 0;

            for (int i = 1; i <= n; i++) {
                sum += i;
            }

            System.out.println("Sum: " + sum);
        }
    }

Explanation:

Initialize sum to 0.
Use a for loop from 1 to n, adding each number to sum.
Print the final sum.