Java Basics Programs - Learning with Nitheesh

Count Digits Without String Conversion

Count the number of digits in a number without using string conversion.

Write a program to count the number of digits in a number without converting it to a string.

Input

4567

Output

Digits Count: 4

public class CountDigits {
    public static void main(String[] args) {
        int num = 4567;
        int count = 0;

        while (num != 0) {
            num /= 10;
            count++;
        }

        System.out.println("Digits Count: " + count);
    }
}

Explanation:

Initialize a counter to 0.
Divide the number by 10 repeatedly until it becomes 0.
Each division removes one digit; increment the counter accordingly.

Digital Root

Repeatedly sum digits of a number until a single digit remains.

Write a program to repeatedly sum the digits of a number until you get a single digit.

Input

9875

Output

Digital Root: 2

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

        while (num > 9) {
            int sum = 0;
            while (num != 0) {
                sum += num % 10;
                num /= 10;
            }
            num = sum;
        }

        System.out.println("Digital Root: " + num);
    }
}

Explanation:

Keep summing the digits of the number.
If the sum is more than one digit, repeat the process.
Stop when a single-digit number is obtained.

Harshad Number Check

Check whether a number is divisible by the sum of its digits.

Write a program to check whether a number is a Harshad (Niven) number.

Input

Output

Yes, it's a Harshad number.

public class HarshadNumber {
    public static void main(String[] args) {
        int num = 18;
        int sum = 0, temp = num;

        while (temp != 0) {
            sum += temp % 10;
            temp /= 10;
        }

        if (num % sum == 0) {
            System.out.println("Yes, it's a Harshad number.");
        } else {
            System.out.println("No, it's not a Harshad number.");
        }
    }
}

Explanation:

Find the sum of the digits of the number.
Check if the original number is divisible by that sum.
If divisible, it is a Harshad number.

LCM Using GCD

Find the Least Common Multiple (LCM) of two numbers using GCD.

Write a program to find the Least Common Multiple (LCM) of two numbers using GCD.

Input

12, 18

Output

LCM: 36

public class LCMUsingGCD {
    public static void main(String[] args) {
        int a = 12, b = 18;
        int gcd = findGCD(a, b);
        int lcm = (a * b) / gcd;

        System.out.println("LCM: " + lcm);
    }

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

Explanation:

Use the Euclidean algorithm to find the GCD of the two numbers.
Apply the formula LCM = (a × b) / GCD.
Print the resulting LCM.

Trailing Zeroes in Factorial

Count the number of trailing zeroes in the factorial of a number.

Write a program to count the number of trailing zeroes in a factorial of a number.

Input

100

Output

Trailing Zeroes: 24

public class TrailingZeroesInFactorial {
    public static void main(String[] args) {
        int n = 100;
        int count = 0;

        for (int i = 5; n / i >= 1; i *= 5) {
            count += n / i;
        }

        System.out.println("Trailing Zeroes: " + count);
    }
}

Explanation:

Trailing zeroes are produced by multiples of 10, which are formed from 2 × 5.
Since factors of 2 are more frequent, count the number of 5s in the factorial.
Use a loop to divide n by 5, 25, 125... and accumulate the quotient.
Print the total count as the number of trailing zeroes.

Reverse Number

Reverse a number without converting it to a string or using arrays.

Write a program to reverse a number without using string conversion or arrays.

Input

1234

Output

Reversed: 4321

public class ReverseNumber {
    public static void main(String[] args) {
        int num = 1234;
        int reversed = 0;

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

        System.out.println("Reversed: " + reversed);
    }
}

Explanation:

Initialize reversed to 0.
Extract the last digit using modulus (% 10).
Append the digit to reversed by multiplying the existing value by 10 and adding the digit.
Remove the last digit from the original number using integer division (/ 10).
Repeat until the number becomes 0 and print the reversed number.

Armstrong Number

Check if a number is an Armstrong number.

Write a program to check if a number is an Armstrong number.

Input

153

Output

Yes, it's an Armstrong number.

public class ArmstrongNumber {
    public static void main(String[] args) {
        int num = 153, original = num, result = 0;
        int digits = String.valueOf(num).length();

        while (num != 0) {
            int digit = num % 10;
            result += Math.pow(digit, digits);
            num /= 10;
        }

        if (result == original)
            System.out.println("Yes, it's an Armstrong number.");
        else
            System.out.println("No, it's not an Armstrong number.");
    }
}

Explanation:

Store the original number for comparison.
Count the number of digits.
Iterate through each digit, raising it to the power of the digit count and summing the result.
If the sum equals the original number, it's an Armstrong number.

Sum of First N Primes

Find the sum of the first N prime numbers.

Write a program to find the sum of the first N prime numbers.

Input

Output

Sum: 28

public class SumOfFirstNPrimes {
    public static void main(String[] args) {
        int n = 5; // Number of prime numbers to sum
        int count = 0, num = 2, sum = 0;

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

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

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

Explanation:

Initialize `count` to track how many primes we've found and `sum` to accumulate the total.
Use a helper function `isPrime` to check primality.
Loop through numbers and add primes to the sum until `count` reaches `n`.
Print the final sum.

GCD of Array

Find the GCD of elements in an array.

Write a program to find the GCD of elements in an array.

Input

[24, 36, 60]

Output

GCD: 12

public class GCDofArray {
    public static void main(String[] args) {
        int[] arr = {24, 36, 60};
        int result = arr[0];

        for (int i = 1; i < arr.length; i++) {
            result = gcd(result, arr[i]);
        }

        System.out.println("GCD: " + result);
    }

    static int gcd(int a, int b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
}

Explanation:

Initialize result as the first array element.
Iterate over the array and find the GCD of `result` with each element.
Use the Euclidean algorithm in the `gcd` function.
The final `result` holds the GCD of all elements.

Count Total Factors

Write a program to count the number of factors of a number.

Input

Output

Total Factors: 6

public class CountTotalFactors {
    public static void main(String[] args) {
        int num = 12;
        int count = 0;

        for (int i = 1; i <= num; i++) {
            if (num % i == 0) {
                count++;
            }
        }

        System.out.println("Total Factors: " + count);
    }
}

Explanation:

Initialize count to 0.
Loop from 1 to the number, checking if the current number divides the input number.
Increment count if a divisor is found.
Print the total count of factors.

Palindrome Number Check

Write a program to check if a number is a palindrome.

Input

1221

Output

Yes, it's a palindrome.

public class PalindromeNumberCheck {
    public static void main(String[] args) {
        int num = 1221;
        int originalNum = num;
        int reversed = 0;

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

        if (originalNum == reversed) {
            System.out.println("Yes, it's a palindrome.");
        } else {
            System.out.println("Not a palindrome.");
        }
    }
}

Explanation:

Store the original number.
Reverse the number by extracting digits and building a new reversed number.
Compare the reversed number with the original.
Print the result accordingly.

Decimal to Binary

Convert a decimal number to binary without using built-in methods.

Write a program to convert decimal number to binary manually.

Input

Output

Binary: 1010

public class DecimalToBinary {
    public static void main(String[] args) {
        int num = 10;
        String binary = "";

        while (num > 0) {
            int remainder = num % 2;
            binary = remainder + binary;
            num = num / 2;
        }

        System.out.println("Binary: " + binary);
    }
}

Explanation:

Repeatedly divide the number by 2.
Store the remainder (0 or 1) each time.
Build the binary string by prepending each remainder.
Print the resulting binary string.

Sum of Two Squares

Check if a number can be expressed as the sum of two square numbers.

Input

Output

Yes (e.g., 7² + 1² = 49 + 1 = 50)

public class SumOfTwoSquares {
    public static void main(String[] args) {
        int n = 50;
        boolean found = false;

        for (int i = 0; i * i <= n; i++) {
            int remainder = n - i * i;
            int j = (int)Math.sqrt(remainder);

            if (j * j == remainder) {
                System.out.println("Yes (e.g., " + i + "² + " + j + "² = " + n + ")");
                found = true;
                break;
            }
        }

        if (!found) {
            System.out.println("No, it cannot be expressed as the sum of two squares.");
        }
    }
}

Explanation:

Iterate i from 0 to √n.
Calculate remainder = n - i².
Check if remainder is a perfect square (j² = remainder).
If yes, print the pair and break; otherwise, print no.

Sieve of Eratosthenes

Generate all prime numbers up to N using Sieve of Eratosthenes.

Generate all prime numbers up to N using the Sieve of Eratosthenes algorithm.

Input

Output

Primes: 2 3 5 7 11 13 17 19 23 29

public class SieveOfEratosthenes {
    public static void main(String[] args) {
        int n = 30;
        boolean[] prime = new boolean[n + 1];
        
        // Initialize all entries as true. A value will be false if it is not a prime.
        for (int i = 2; i <= n; i++) {
            prime[i] = true;
        }

        for (int p = 2; p * p <= n; p++) {
            if (prime[p]) {
                for (int i = p * p; i <= n; i += p) {
                    prime[i] = false;
                }
            }
        }

        System.out.print("Primes: ");
        for (int i = 2; i <= n; i++) {
            if (prime[i]) {
                System.out.print(i + " ");
            }
        }
    }
}

Explanation:

Initialize a boolean array marking all numbers as potential primes.
Start from the first prime number (2) and mark its multiples as non-prime.
Repeat for next unmarked numbers up to √n.
Print all numbers still marked as prime.

Digits That Divide the Number

Count digits of a number that divide it completely.

Input

1012

Output

Count: 3

public class DigitsThatDivideNumber {
    public static void main(String[] args) {
        int num = 1012;
        int temp = num;
        int count = 0;

        while (temp > 0) {
            int digit = temp % 10;
            temp /= 10;

            if (digit != 0 && num % digit == 0) {
                count++;
            }
        }

        System.out.println("Count: " + count);
    }
}

Explanation:

Extract each digit from the number.
Check if digit is non-zero and divides the number without remainder.
Increment count for every such digit.
Print the count.

Power of Number Using Recursion

Write a recursive function to calculate a^b.

Input

2⁵

Output

Result: 32

public class PowerUsingRecursion {
    public static void main(String[] args) {
        int base = 2;
        int exponent = 5;
        int result = power(base, exponent);
        System.out.println("Result: " + result);
    }

    public static int power(int a, int b) {
        if (b == 0) return 1;
        return a * power(a, b - 1);
    }
}

Explanation:

If exponent is 0, return 1 (base case).
Recursively multiply the base a by the result of power(a, b-1).
Return the computed result.

Largest Prime Factor

Write a program to find the largest prime factor of a number.

Input

13195

Output

Largest Prime Factor: 29

public class LargestPrimeFactor {
    public static void main(String[] args) {
        long num = 13195;
        long largestFactor = largestPrimeFactor(num);
        System.out.println("Largest Prime Factor: " + largestFactor);
    }

    public static long largestPrimeFactor(long n) {
        long maxPrime = -1;

        // Divide out the factor 2
        while (n % 2 == 0) {
            maxPrime = 2;
            n /= 2;
        }

        // Divide out odd factors
        for (long i = 3; i <= Math.sqrt(n); i += 2) {
            while (n % i == 0) {
                maxPrime = i;
                n /= i;
            }
        }

        // If n is a prime number > 2
        if (n > 2)
            maxPrime = n;

        return maxPrime;
    }
}

Explanation:

Divide the number by 2 repeatedly to remove all factors of 2.
Check for odd factors from 3 up to the square root of the remaining number.
Update the largest prime factor whenever a factor divides the number.
If the remaining number is greater than 2, it is a prime and largest factor.

Perfect Square Check (Binary Search)

Check whether a number is a perfect square using binary search.

Input

Output

Yes, it's a perfect square.

public class PerfectSquareBinarySearch {
    public static void main(String[] args) {
        int num = 64;
        if (isPerfectSquare(num)) {
            System.out.println("Yes, it's a perfect square.");
        } else {
            System.out.println("No, it's not a perfect square.");
        }
    }

    public static boolean isPerfectSquare(int num) {
        if (num < 0) return false;

        int low = 0, high = num;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            long square = (long) mid * mid;

            if (square == num) {
                return true;
            } else if (square < num) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return false;
    }
}

Explanation:

Use binary search between 0 and the number.
Calculate mid and its square in each iteration.
If square equals the number, it's a perfect square.
If square is less, move low to mid+1; else move high to mid-1.
If no exact square found, number is not a perfect square.

Nearest Palindrome Number

Find the nearest palindrome to a given number.

Input

123

Output

Nearest Palindrome: 121

public class NearestPalindrome {
    public static void main(String[] args) {
        int num = 123;
        System.out.println("Nearest Palindrome: " + nearestPalindrome(num));
    }

    public static int nearestPalindrome(int num) {
        if (num < 0) return 0; // No negative palindrome considered
        
        int lower = num - 1;
        int higher = num + 1;
        
        while (true) {
            if (isPalindrome(lower)) return lower;
            if (isPalindrome(higher)) return higher;
            lower--;
            higher++;
        }
    }

    public static boolean isPalindrome(int num) {
        int original = num;
        int reversed = 0;
        while (num > 0) {
            int digit = num % 10;
            reversed = reversed * 10 + digit;
            num /= 10;
        }
        return original == reversed;
    }
}

Explanation:

Start checking numbers less than and greater than the input simultaneously.
Use the palindrome check helper method for each candidate.
Return the first palindrome found closest to the input.

Count Set Bits in Binary Representation

Count the number of 1s in the binary representation of a number.

Input

Output

Set Bits: 3

public class CountSetBits {
    public static void main(String[] args) {
        int num = 13;
        System.out.println("Set Bits: " + countSetBits(num));
    }

    public static int countSetBits(int num) {
        int count = 0;
        while (num > 0) {
            count += (num & 1);  // Check last bit
            num >>= 1;           // Right shift
        }
        return count;
    }
}

Explanation:

Initialize count to 0.
Use bitwise AND with 1 to check if the last bit is set.
Right shift the number by 1 and repeat until number becomes 0.
Return the total count of set bits.

Java Numbers Intermediate Programs

Count Digits Without String Conversion

Digital Root

Harshad Number Check

LCM Using GCD

Trailing Zeroes in Factorial

Reverse Number

Armstrong Number

Sum of First N Primes

GCD of Array

Count Total Factors

Palindrome Number Check

Decimal to Binary

Sum of Two Squares

Sieve of Eratosthenes

Digits That Divide the Number

Power of Number Using Recursion

Largest Prime Factor

Perfect Square Check (Binary Search)

Nearest Palindrome Number

Count Set Bits in Binary Representation