Java Program to Check Even and Odd Number.

In this program, we will check if the given number is even or odd. To solve this program we must have a basic understanding of if...else statement in Java.

Algorithm for the Java program to check whether a given number is even or odd:

• Step 1: Start

• Step 2: Read the input number from the user

• Step 3: Check if the input number is even or odd:
• a. If the number is divisible by 2 with no remainder, then it is even
• b. If the number is not divisible by 2 with a remainder of 1, then it is odd

• Step 4: Print the result to the console

• Step 5: End

Java Code Implementation:

import java.util.Scanner;

public class EvenOdd {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int num = input.nextInt();
        if (num % 2 == 0) {
            System.out.println(num + " is even");
        } else {
            System.out.println(num + " is odd");
        }
    }
}

Output:

Enter a number: 12
12 is even

We use an if-else statement to check whether the num is even or odd. We do this by checking whether num is divisible by 2 using the modulo operator %. If num % 2 is 0, then num is even; otherwise, it is odd.

Finally, we print out the result using the println method of the System.out object.

Swap Two Numbers in Java.

We can swap two numbers in Java with multiple approaches and in this article, we are going to discuss all those approaches in detail with code.

Approach 1: Using a third variable

In this approach, we use a third variable to swap the values of the two variables.

Java Example Code:

int a = 10;
int b = 20;
int temp;

temp = a;
a = b;
b = temp;

System.out.println("a = " + a); // Output: a = 20
System.out.println("b = " + b); // Output: b = 10

Approach 2: Using arithmetic operations

In this approach, we can use arithmetic operations like addition, subtraction, multiplication, and division to swap the values of the two variables.

Java Example Code:

int a = 10;
int b = 20;

a = a + b; // a = 30
b = a - b; // b = 10
a = a - b; // a = 20

System.out.println("a = " + a); // Output: a = 20
System.out.println("b = " + b); // Output: b = 10

Approach 3: Using the XOR operator

In this approach, we can use the XOR (^) operator to swap the values of the two variables.

Java Example Code:

int a = 10;
int b = 20;

a = a ^ b; // a = 30 (11110)
b = a ^ b; // b = 10 (01010)
a = a ^ b; // a = 20 (10100)

System.out.println("a = " + a); // Output: a = 20
System.out.println("b = " + b); // Output: b = 10

All these approaches have the same time complexity of O(1) as they take constant time to swap the values of two variables. (alert-success)

Check Leap Year in Java.

In this article, we are going learn how to check if the given year is a leap year or not using Java Programming and we will use Java if-else condition to solve this problem.

Leap Year are those Year in which we have 366 days whereas a normal Year contains 365 days. In leap year, the month Feburary contain 29 days. (alert-success)

Algorithm for Leap Year.

Below algorithm used to check if a year is a leap year or not:

• Take an input year from the user.
• If the year is evenly divisible by 4, go to step 3. Otherwise, go to step 6.
• If the year is evenly divisible by 100, go to step 4. Otherwise, go to step 5.
• If the year is evenly divisible by 400, go to step 5. Otherwise, go to step 6.
• The year is a leap year (it has 366 days).
• The year is not a leap year (it has 365 days).

Java Code Implementation to Find Leap Year.

import java.util.Scanner;

public class LeapYear {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int year;
        
        // Prompt user to enter a year
        System.out.print("Enter a year: ");
        year = input.nextInt();
        
        // Check if the entered year is a leap year
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
            System.out.println(year + " is a leap year");
        }
        else {
            System.out.println(year + " is not a leap year");
        }
    }
}

Output 1:

Enter a year: 2020
2020 is a leap year

Output 1:

Enter a year: 2022
2020 is not a leap year

In the above code, a year is a leap year if it is divisible by 4 but not divisible by 100, or if it is divisible by 400. This algorithm is based on the rules of the Gregorian calendar, which is the calendar system used in most of the world today.

Find Largest Among Three Numbers in Java.

In this article, we are going to learn Java programs to find the greatest number among three integer numbers. There are multiple ways to solve this program and we will each of them one by one.

Approach 1: Find the Greatest using if-else statement.

In this approach, we will use if-else statements to compare the three numbers and find the greatest among them.

Java Example Code:

import java.util.Scanner;

public class GreatestOfThreeNumbers {

   public static void main(String[] args) {

      int num1, num2, num3;
      Scanner input = new Scanner(System.in);

      System.out.println("Enter three numbers:");
      num1 = input.nextInt();
      num2 = input.nextInt();
      num3 = input.nextInt();

      if (num1 > num2 && num1 > num3) {
         System.out.println(num1 + " is the greatest.");
      }
      else if (num2 > num1 && num2 > num3) {
         System.out.println(num2 + " is the greatest.");
      }
      else {
         System.out.println(num3 + " is the greatest.");
      }
   }
}

Output:

Enter three numbers:
12
23
11
23 is the greatest.

Here, we are taking input of three numbers from the user using the Scanner class. Then, we are using if-else statements to compare the numbers and print the greatest among them.

Approach 2: Using Math.max() method.

In this approach, we will use the Math.max() method to find the greatest among the three numbers.

Java Example Code:

import java.util.Scanner;

public class GreatestOfThreeNumbers {

   public static void main(String[] args) {

      int num1, num2, num3;
      Scanner input = new Scanner(System.in);

      System.out.println("Enter three numbers:");
      num1 = input.nextInt();
      num2 = input.nextInt();
      num3 = input.nextInt();

      int greatest = Math.max(num1, Math.max(num2, num3));
      System.out.println(greatest + " is the greatest.");
   }
}

Output:

Enter three numbers:
10
23
15
23 is the greatest.

Here, we are using the Math.max() method to find the greatest among the three numbers. We are taking input of three numbers from the user using the Scanner class and then passing them as arguments to the Math.max() method. The Math.max() method returns the greatest of the two numbers passed as arguments, so we are calling it twice to compare all three numbers.

Approach 3: Using Array and Loops.

In this approach, we will use arrays and loops to find the greatest among the three numbers.

Java Example Code:

//Java code for finding greatest number
import java.util.Scanner;

public class GreatestOfThreeNumbers {

   public static void main(String[] args) {

      int[] nums = new int[3];
      Scanner input = new Scanner(System.in);

      System.out.println("Enter three numbers:");
      for (int i = 0; i < 3; i++) {
         nums[i] = input.nextInt();
      }

      int greatest = nums[0];
      for (int i = 1; i < 3; i++) {
         if (nums[i] > greatest) {
            greatest = nums[i];
         }
      }
      System.out.println(greatest + " is the greatest.");
   }
}

Output:

Enter three numbers:
19
29
15
29 is the greatest.

Here, we are using an array to store the three numbers entered by the user. We are taking input of three numbers from the user using the Scanner class and then using a loop to store them in the array. Then, we are using another loop to compare the numbers in the array and find the greatest among them.

Find Factorial of a Number in Java.

In this article, we will learn multiple approaches to finding the factorial of a number in Java Programming. Before moving to the code part lets us first understand what is Factorial and how to calculate it. 

What is the Factorial of a Number?

Factorial is a mathematical operation that is used to calculate the product of all positive integers from 1 to a given positive integer n. 

It is denoted by the symbol "!" and is defined as follows:

• n! = n x (n-1) x (n-2) x ... x 3 x 2 x 1

For example, the factorial of 5 is calculated as:

• 5! = 5 x 4 x 3 x 2 x 1 = 120
• The factorial of 0 is defined to be 1 by convention, that is: 0! = 1

We can find the factorial of a number using the following approaches:

Find Factorial using for loop.

In this approach, we use a for loop to multiply each number from 1 to n, where n is the number for which we need to find the factorial.

Java Code:

//Java code to find factroil of a number using for loop
import java.util.Scanner;

public class HelloWrold {

  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.print("Enter a number: ");
    int n = input.nextInt();
    int factorial = 1;
    for (int i = 1; i <= n; i++) {
      factorial *= i;
    }
    System.out.println("Factorial of " + n + " is " + factorial);
  }
}

Output:

Enter a number: 5
Factorial of 5 is 120

• Time Complexity: O(n)
• Space Complexity: O(1)

Find Factorial using Recursion.

In this approach, we use a recursive function to find the factorial of a number. A recursive function is a function that calls itself.

Java Code:

//Java code to find factroil of a number using Recursion
import java.util.Scanner;

public class Factorial {

  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.print("Enter a number: ");
    int n = input.nextInt();
    int factorial = fact(n);
    System.out.println("Factorial of " + n + " is " + factorial);
  }

  public static int fact(int n) {
    if (n == 0) {
      return 1;
    }
    return n * fact(n - 1);
  }
}

Output:

Enter a number: 5
Factorial of 5 is 120

• Time Complexity: O(n)
• Space Complexity: O(n)

Find Factorial using a while loop.

In this approach, we use a while loop to multiply each number from 1 to n, where n is the number for which we need to find the factorial.

Java Code:

//Java code to find factroil of a number using while loop
import java.util.Scanner;

public class Factorial {

  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.print("Enter a number: ");
    int n = input.nextInt();
    int factorial = 1;
    int i = 1;
    while (i <= n) {
      factorial *= i;
      i++;
    }
    System.out.println("Factorial of " + n + " is " + factorial);
  }
}

Output:

Enter a number: 10
Factorial of 5 is 3628800

• Time Complexity: O(n)
• Space Complexity: O(1)

Java Program to Check Prime Number.

In this article, we are going to discuss different approaches to checking if a number is in Prime or not using Java Programming. Before moving to the code part let us understand what are Prime Numbers.

What is Prime Number?

A prime number is a positive integer greater than 1 that has no positive integer divisors other than 1 and itself. In other words, a prime number can only be divided evenly by 1 and itself.

For example, the first few prime numbers are 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, and so on.

There are multiple ways to check if a number is prime or not in Java.

• Check Prime Number using Loop.
• Check Prime Number using the square root property.
• Check Prime Number using the Sieve of Eratosthenes.

Check Prime Number using Loop.

To check if a number is prime is to use a loop and iterate from 2 to n/2 (where n is the number we want to check) and check if n is divisible by any number in this range. If n is divisible by any number in this range, then it is not prime.

Java Code Implementation:

// Java code to check prime using loop
class CheckPrime {
    public static void main(String[] args) {
        boolean check = isPrime(11);
        if(check){
            System.out.println("Number is Prime!");
        }
        else{
            System.out.println("Number is not Prime!");
        }
    }
    public static boolean isPrime(int n) {
        if (n <= 1) {
           return false;
        }
        for (int i = 2; i <= n/2; i++) {
           if (n % i == 0) {
              return false;
           }
        }
        return true;
    }
}

Output:

Number is Prime!

Time Complexity:

• The time complexity of this approach is O(n/2) = O(n), where n is the input number. This is because the loop iterates from 2 to n/2 and checks if n is divisible by any of these numbers.

Space Complexity:

• The space complexity of this approach is O(1) because only a constant amount of memory is used to store the loop variable and other variables.

Check Prime Number using the square root property.

This approach is to check if n is divisible by any number in the range 2 to sqrt(n) (where sqrt(n) is the square root of n). This approach is more efficient because it reduces the number of iterations in the loop.

Java Code Implementation:

// Java code to check prime using the square root property
class CheckPrime {
    public static void main(String[] args) {
        boolean check = isPrime(7);
        if(check){
            System.out.println("Number is Prime!");
        }
        else{
            System.out.println("Number is not Prime!");
        }
    }
    //function to check 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;
    }
}

Output:

Number is Prime!

Time Complexity:

• The time complexity of this approach is O(sqrt(n)), where n is the input number. This is because the loop iterates from 2 to sqrt(n) and checks if n is divisible by any of these numbers.

Space Complexity:

• The space complexity of this approach is O(1) because only a constant amount of memory is used to store the loop variable and other variables.

Check Prime Number using the Sieve of Eratosthenes.

This is a more advanced approach to finding all the prime numbers up to a certain limit. 

This algorithm involves creating a boolean array of size n+1 and setting all the values to true. We then iterate from 2 to sqrt(n) and mark all multiples of each number as false. Finally, we iterate through the boolean array and return all the indexes that are marked as true.

Java Code Implementation:

// Java code to check prime using the Sieve of Eratosthenes
import java.util.Arrays;

class HelloWorld {
    public static void main(String[] args) {
        boolean check = isPrime(7);
        if(check){
            System.out.println("Number is Prime!");
        }
        else{
            System.out.println("Number is not Prime!");
        }
    }
    public static boolean[] sieveOfEratosthenes(int n) {
        boolean[] prime = new boolean[n+1];
        Arrays.fill(prime, true);
        prime[0] = false;
        prime[1] = false;
        for (int i = 2; i <= Math.sqrt(n); i++) {
           if (prime[i]) {
               for (int j = i*i; j <= n; j += i) {
                   prime[j] = false;
               }
           }
        }
        return prime;
    }

    public static boolean isPrime(int n) {
       if (n <= 1) {
           return false;
       }
       boolean[] primes = sieveOfEratosthenes(n);
       return primes[n];
    }
}

Output:

Number is Prime!

Time Complexity:

• The time complexity of the Sieve of Eratosthenes algorithm is O(n log log n), where n is the input number. This is because the algorithm involves iterating through all numbers up to n and marking multiples of each prime number as composite.

Space Complexity:

• The space complexity of this approach is O(n) because we need to store a boolean array of size n+1 to mark all numbers as prime or composite.

Java Program to Reverse a String.

In this article, we will understand multiple approaches to reverse a string in Java Programming. 

We can reverse a string using the below approaches:

• Reverse a string using a loop.
• Reverse a string using the StringBuilder class.
• Reverse a string using Recursion.

Let,s discuss each of them one by one,

Reverse a string using a loop.

One way to reverse a string is to use a loop and iterate through the characters of the string in reverse order. We can then append each character to a new string to create the reversed string.

Java Code Implementation:

// Java code to reverse string using loop
class HelloWorld {
    public static void main(String[] args) {
        String str = "Algolesson";
        System.out.println(reverseString(str));
    }
    public static String reverseString(String str) {
       String reversed = "";
       for (int i = str.length() - 1; i >= 0; i--) {
          reversed += str.charAt(i);
       }
       return reversed;
   }
}

Output:

nosseloglA

• Time Complexity: O(n)
• Space Complexity: O(n)

Reverse a String using StringBuilder Class.

Java provides a StringBuilder class that has a reverse() method to reverse a string. We can create a StringBuilder object and then call the reverse() method to get the reversed string. This is the most efficient approach to reversing a string.

Java Code Implementation:

// Java code to reverse string using StringBuilder class
class HelloWorld {
    public static void main(String[] args) {
        String str = "Algolesson";
        System.out.println(reverseString(str));
    }
    public static String reverseString(String str) {
        StringBuilder sb = new StringBuilder(str);
        sb.reverse();
        return sb.toString();
    }
}

Output:

nosseloglA

• Time Complexity: O(n)
• Space Complexity: O(n)

Reverse a String using Recursion.

This approach is to use recursion to reverse a string. We can recursively swap the first and last characters of the string until we reach the middle of the string. This is the least efficient approach and can cause a stack overflow if the string is very long. 

Java Code Implementation:

// Java code to reverse string using Recursion
class HelloWorld {
    public static void main(String[] args) {
        String str = "Algolesson";
        System.out.println(reverseString(str));
    }
    public static String reverseString(String str) {
        if (str.isEmpty()) {
           return str;
        } else {
           return reverseString(str.substring(1)) + str.charAt(0);
        }
    }
}

Output:

nosseloglA

• Time Complexity: O(n)
• Space Complexity: O(n)