List of logical programs in Java

The programming paradigm that is mostly based on formal logic is referred to as Logical Programming. The logical Java programs are mostly asked by the interviewers like Fibonacci series, Armstrong Number, Prime Number, and Perfect Number, etc. The Logical programs are designed by using certain logic and can say 70 percent code of the program is a set of logic.

There can be the following logical programs which are mostly asked:

Fibonacci Series.
Armstrong Number.
Perfect number.
Prime number.
Factorial of a number.
Reverse a string.
Reverse a number.
Palindrome number
Palindrome string.
Find duplicate characters in a string.

Let's understand each of the above logical programs one by one.

1) Fibonacci Series

Fibonacci series is a special type of series in which the next term is the sum of the previous two terms. For example, if 0 and 1 are the two previous terms in a series, then the next term will be 1(0+1).

In Java, we can make the Fibonacci series program either by using the recursion or without recursion. Let's understand the program of the Fibonacci series by using recursion or without recursion one by one.

FibonacciWithoutRecursion.java

import java.util.*;
class FibonacciWithoutRecursion{  
	public static void main(String args[])  
	{    
		int number1=0, number2=1, number3, i, count=5;    
		//printing 0 and 1
		System.out.print(number1+" "+number2);
		
		//0 and 1 is already printed so loop will start with 2
		for(i=2; i<count; ++i)    
		{    
			number3 = number1+number2;    
			System.out.print(" "+number3);    
			number1 = number2;    
			number2 = number3;    
		}    
	}
}

Output

FibonacciWithRecursion.java

class FibonacciWithRecursion{  
 	static int number1=0, number2=1,number3=0;    
	static void Fibo(int count){    
		if(count>0){    
			number3 = number1 + number2;    
			number1 = number2;    
			number2 = number3;    
			System.out.print(" "+number3);   
			Fibo(count-1);    
		}    
	}    
	public static void main(String args[]){    
		int count=5;
		//print 0 and 1
		System.out.print(number1+" "+number2);    
		//2 numbers are already printed so using recursion we print the remaining n-2 numbers
		Fibo(count-2);   
	}	  
} 

Output

2) Armstrong Number

An Armstrong Number is a special positive number whose sum of cubes of its digit is equal to that number. The number 154 is an Armstrong number because if we perform the sum of cubes of each digit, it will result in the same number.

= 153

= (1)³+(5)³+(3)³

= 1+125+27

= 153

Let's understand the logic of checking whether a number is Armstrong or not.

ArmstrongNumber.java

class ArmstrongNumber{  
  public static void main(String[] args)  {  
    int sumOfCube=0,a,temp;  
    int number=153;  
    temp=number;  
    while(number>0)  
    {  
		a=number%10; //Getting last digit
		number=number/10;  //Removing last digit from number
		sumOfCube=sumOfCube+(a*a*a); //Calculating sum of cubes of digits  
    }  
    if(temp==sumOfCube)  
		System.out.println(temp+" is an armstrong number");   
    else  
        System.out.println(temp+ "is not an armstrong number");   
   }  
}

Output

3) Perfect Number

Just like the Armstrong number, the Perfect Number is also a special type of positive number. When the number is equal to the sum of its positive divisors excluding the number, it is called a Perfect Number. For example, 28 is the perfect number because when we sum the divisors of 28, it will result in the same number. The divisors of 28 are 1, 2, 4, 7, and 14. So,

28 = 1+2+4+7

28 = 28

Let's understand the logic of checking whether a number is Perfect or not.

PerfectNumber.java

import java.util.*;

//Creating PerfectNumber class
class PerfectNumber 
{ 
      
	// Creating check() method that will return true when number will be perfect 
	static boolean check(int number) 
	{ 
		int sum = 1; 
  
		// Finding all the divisors 
		for (int j = 2; j * j <= number; j++) 
		{ 
			if (number % j==0) 
			{ 
				if(j * j != number) 
					sum = sum + j + number / j; 
				else
					sum = sum + j; 
			} 
		}  
		// Checking whether the sum of the divisors and number both are equal or not
		if (sum == number && number != 1) 
			return true; 
  
		return false; 
	} 
  
	// Main() method 
	public static void main (String[] args) 
	{ 
		System.out.println("Perfect numbers between 0-5000:"); 
		for (int n = 2; n < 5000; n++){ 
			if (check(n)) 
				System.out.println( n +" is a perfect number"); 
		}
	} 
}

Output

4) Prime Number

Just like the Perfect and Armstrong number, Prime number is also a special type of number. When the number is divided greater than 1 and divided by 1 or itself is referred to as the Prime number. 0 and 1 are not counted as prime numbers. All the even numbers can be divided by 2, so 2 is the only even prime minister.

Let's understand the logic of checking whether a number is prime or not.

PrimeNumber.java

import java.util.*;

//Creating PrimeNumber class
public class PrimeNumber{    
	//Creating check() method to ensure whether the given number is prime number or not
	static Boolean check(int number){  
		int i,m=0,flag=0;      
		m=number/2; 
		
		//Returning false when the number is either 0 or 1 because 0 and 1 cannot be prime numbers 
		if(number==0||number==1){  
			return false;      
		}else{
			//When the number is not 0 and 1
			for(i=2;i<=m;i++){      
				if(number%i==0){      
					return false;      
				}	      
			}      
			return true; 
		}//end of else  
	}  
	public static void main(String args[]){    
		for(int i=0; i<=50; i++){
			if(check(i)){
				System.out.println(i+" is a Prime number");
			}
		}
	}
}

Output

5) Factorial of a number

The product of all positive integers which are less than or equal to the given positive number is referred to as the factorial of that given integer number. For example, the factorial of the number 8 can be calculated by multiplying all the integers which are less than or equal to the 8 like this:

= 8

= 8*7*6*5*4*3*2*1

= 40320

Let's understand the logic of calculating the factorial of a number.

FactorialExample.java

//Creating FactorialExample class
class FactorialExample{  
	//main() method starts 
	public static void main(String args[]){  
		int i,factorial=1;  

		int n = 8;  // Number whose factorial we want to calculate
		//Calculating factorial of number 8
		for(i=1;i<=n;i++){    
			factorial = factorial*i;    
		}
		// Showing factorial of the number    
		System.out.println(factorial+" is the factorial of: "+n);    
	}  
}

Output

6) Reverse a string

The reverse of a string is another logical program that is mostly asked by the interviewers. We can reverse a string either by using the StringBuilder/StringBuffer or by reverse iteration.

Let's understand the logic of how to reverse a string by using iteration or StringBuilder/StringBuffer:

ReverseString.java

import java.util.*;

//Creating ReverseString class
public class ReverseString {  
	//Creating performReverse() method to reverse a string
	public static void performReverse(String str){  
		//Reverse string using StringBuilder
		//Creating instance of the StringBuilder
		StringBuilder newString = new StringBuilder(str);	
		
		//Using reverse() method to reverse string 
		newString.reverse();
		//Showing reverse string 
		System.out.println("Reverse string using StringBuilder: "+newString.toString());    
		
		//Reverse string using string iteration
		//Converting string to character array
		char ch[] = str.toCharArray();  
		String reverseString="";  
		//Reverse string using character array
		for(int i = ch.length-1; i >= 0 ; i--){  
			reverseString+=ch[i];  
		}
		//Showing reverse string
		System.out.println("Reverse string using string iteration: "+reverseString); 
	}
	//main() method starts
	public static void main(String[] args) { 
		
		//Getting string from the user
		Scanner sc = new Scanner(System.in); 
        String name = sc.nextLine();
		
		//Calling performReverse() method to perform reverse
		performReverse(name);
	}
}

Output

7) Reverse a number

Just like String, a program of reversing a number is also frequently asked by the interviewers. In Java, we can reverse a number either by using for loop, while loop, or using recursion. The simplest way to reverse a number is by using for loop or while loop. In order to reverse a number, we have to follow the following steps:

We need to calculate the remainder of the number using the modulo
After that, we need to multiply the variable reverse by 10 and add the remainder into it.
We then divide the number by 10 and repeat steps until the number becomes 0.

Let's understand the logic of reversing a number by using the loop.

ReverseNumber.java

import java.util.*;

//Creating ReverseNumber class
public class ReverseNumber{  
	//Creating performReverse() method to reverse a number
	public static void performReverse(int number){  
		int rev = 0;
		int temp = number;
		while(number != 0)   
		{  
			//Calculating reminder
			int rem = number % 10; 
			//multiplying variable reverse by 10 and adding the reminder into it
			rev = rev * 10 + rem;  
			//Divide the number
			number = number/10;  
		}  
		System.out.println(rev+" is the reverse of the number "+temp);  
	}	

	//main() method starts
	public static void main(String[] args) { 
	
		//Getting number from the user
		Scanner sc = new Scanner(System.in); 
		int number = sc.nextInt();
	
		//Calling performReverse() method to perform reverse
		performReverse(number);
	}
}

Output

8) Palindrome number

A palindrome number is a special number. After reversing a number, if it is the same as the original number referred to as a palindrome number. There can be a series of palindrome numbers. For example, 121, 232, 34543, 171, and 343 etc.

Let's understand the logic of checking whether a number is a palindrome or not.

PalindromeNumber.java

import java.util.*;

//Creating PalindromeNumber class
public class PalindromeNumber{  
	//Creating checkPalindrome() method to check number
	public static void checkPalindrome(int number){  
		int rem, sum=0, temp;    
		//Storing value of number into temp variable
		temp=number;    
		
		//Reversing number
		while(number>0){    
			rem = number%10;  //getting remainder  
			sum = (sum*10)+rem;    
			number = number/10;    
		} 

		//Checking whether the reversing number is equal to the number or not
		if(temp==sum)    
			System.out.println(temp+" is a palindrome number");    
		else    
			System.out.println(temp+ "is not a palindrome");        
	}	

	//main() method starts
	public static void main(String[] args) { 
	
		//Getting number from the user
		Scanner sc = new Scanner(System.in); 
		int number = sc.nextInt();
	
		//Calling checkPalindrome() method to check whether the given number is palindrome or not
		checkPalindrome(number);
	}
}

Output

9) Palindrome string

Just like a number, a string can also be a palindrome. The logic of checking a string is different from the number.

Let's understand the logic of checking string palindrome.

PalindromeString.java

import java.util.*;

//Creating PalindromeString class
public class PalindromeString{  
	//Creating checkPalindrome() method to check string
	public static void checkPalindrome(String str){  
		String rev = ""; // Objects of String class   
		int length;
		
		//Getting length of the string
		length = str.length();   
		
		//Reversing string
		for ( int j = length - 1; j >= 0; j-- )  
			rev = rev + str.charAt(j);
		
		//Cheking whether the given string is equal to the reverse string or not 
		if (str.equals(rev))  
			System.out.println(str+" is a palindrome string.");  
		else  
			System.out.println(str+" is not a palindrome string.");        
	}	

	//main() method starts
	public static void main(String[] args) { 
	
		//Getting string from the user
		Scanner sc = new Scanner(System.in); 
		String str = sc.nextLine();
	
		//Calling checkPalindrome() method to check whether the given string is palindrome or not
		checkPalindrome(str);
	}
}

Output

10) Find duplicate characters in a string.

Finding duplicate characters in a string is another logical program that is also frequently asked by the interviewers. We can find the duplicate characters in a string and the occurrence of that character in a string.

The logic of this program is a little tricky because there are two processes, i.e., finding the duplicate characters and occurrence of that character.

Let's understand the logic of finding the duplicate characters in a string.

DuplicateCharacters .java

import java.util.*;

//Creating DuplicateCharacters class
public class DuplicateCharacters{  
//Creating findDuplicates() method to find duplicate characters
	public static void findDuplicates(String str){  
		int count;  
          
        		//Converting given string into character array  
       		char strArray[] = str.toCharArray();  
          
        		System.out.println(" Duplicate characters in a given string:  " );  
        		//Counting each character present in the string  
        		for(int i = 0; i <strArray.length; i++) {  
            			count = 1;  
           			for(int j = i+1; j <strArray.length; j++) {  
                			if(strArray[i] == strArray[j] && strArray[i] != ' ') {  
                    				count++;  
                    				//Set strArray[j] to 0 to avoid printing visited character  
                    				strArray[j] = '0';  
                			}  
            			}  
            			//A character is considered as duplicate if count is greater than 1  
            			if(count > 1 && strArray[i] != '0')  
                			System.out.println(str+" contains "+strArray[i]+" "+ count + " times");  
        		}         
	}	

	//main() method starts
	public static void main(String[] args) { 
	
		//Getting string from the user
		Scanner sc = new Scanner(System.in); 
		String str = sc.nextLine();
	
		//Calling findDuplicates() method to find the duplicate characters in the string
		findDuplicates(str);
	}
}

Output