# Java Program: Print characters having prime frequencies in order of occurrence

Question : Print characters having prime frequencies in order of occurrence

Given a string str containing only lowercase characters. The task is to print the characters having prime frequency in the order of their occurrence. Note that repeated elements with prime frequencies are printed as many times as they occur in order of their occurrence.

Examples:

• Input: str = “facingissuesonit”
Output: facingissuesonit Frequency
‘f’ 1
‘a’ 1
‘c’ 1
‘i’ 3
‘n’ 2
‘g’ 1
‘s’ 3
‘u’ 1
‘e’ 1
‘o’ 1
‘t’ 1

‘i’, ‘n’ and ‘s’ are the only characters with prime frequencies.
Output: insinsis

• Input: str = “aeroplane”
Output: aeae

# Algorithm

• Step 1: Ask the user to input String
• Step 2: Get count of each character occurrence and insert in character-based sorted map
• Step 3: Remove Character those occurrences are not Prime
• Step 4: Print Character in alphabetical order and reduce the count by one
• Step 5: Remove an entry from the map if the count is zero
• Step 6: Repeat step 4 and 5 until map get empty

# Java Program

```public class Program2 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);
System.out.print("Enter a text String: ");
String inputStr = input.nextLine();
System.out.println("Result :" + primePlacesString(inputStr));
}

private static List primePlacesString(String inputStr) {
List charList = null;
char[] chars = inputStr.toCharArray();
// Enter Character and respected occurence in map
TreeMap map = new TreeMap();
for (Character c : chars) {
if (map.get(c) == null) {
map.put(c, 1);
} else {
map.put(c, map.get(c).intValue() + 1);
}
}
// Removed character those occurence are not prime
Character[] keys = (Character[]) map.keySet().toArray(new Character[map.size()]);
for (Character key : keys) {
map.remove(key);
}
}
// get list of character in sequence as per counts
if (map != null && !map.isEmpty()) {
charList = new ArrayList();
printMapInSquence(map, charList);
}
return charList;
}

// Code to check number is prime or not
private static boolean isPrimeNumber(Integer number) {
if (number == 0 || number == 1) {
} else {
for (int i = 2; i <= number / 2; i++) {
if (number % i == 0) {
break;
}
}
}

}

private static void printMapInSquence(Map map, List charList) {
if (map != null && !map.isEmpty()) {

Character[] keys = (Character[]) map.keySet().toArray(new Character[map.size()]);
for (Character key : keys) {
if (map.get(key) == 1) {
// remove characters those are already printed and count are 1
map.remove(key);
} else {
// reduce counts of printed characters and counts more than one
map.put(key, map.get(key) - 1);
}
}
printMapInSquence(map, charList);
}
}

}

```

# Output

``````
Enter a text String: facingissuesonit
Result :[i, n, s, i, n, s, i, s]

Enter a text String: aeroplane
Result :[a, e, a, e]
``````

# Java Program : Get all possible values of X such that A % X = B

Question:  Write a java program to get  all possible values of X such that A % X = B. Input two integers A and B. The task is to find the  all possible values X such that A % X = B. If there are infinite number of possible values then print -1.

Examples:

1. Input: A = 21, B = 5
Output: 2
8 and 16 are the only valid values for X.
2. Input: A = 5, B = 5
Output: -1
X can have any value > 5

# Algorithm

• Step 1: Ask the user to input values of A and B
• Step 2: Find out all possible factors of (A-B) which are greater than B
• Step 3: Use StringJoiner to print the possible value in comma separated form.

# Java Program

```public class Program1 {
public static void main(String[] args) {
System.out.println("Enter values of A and B to get possible values of X from expression A % X = B");

Scanner input = new Scanner(System.in);
System.out.print("Please Enter an integer A: ");
int A = input.nextInt();

System.out.print("Please Enter an integer B: ");
int B = input.nextInt();

System.out.println("Possible Values of X :" + getAllowedValues(A, B));
}

private static String getAllowedValues(int A, int B) {
//Use to print value in comma separated form
StringJoiner joiner = new StringJoiner(",");

if (A - B > 0) {
//find out all possible factor of(A-B) which are greater than B
for (int C = (A - B); C > 0 & C > B; C /= 2) {
if ((A - B) % C == 0)
}
} else {
}
return joiner.toString();
}

}
```

## Output

``````
Enter values of A and B to get possible values of X from expression A % X = B
Please Enter an integer A: 21
Please Enter an integer B: 5
Possible Values of X :16,8

Enter values of A and B to get possible values of X from expression A % X = B
Please Enter an integer A: 5
Please Enter an integer B: 5
Possible Values of X :-1

``````

# Mathematical Programming Test

Here are some most common formulae based mathematical programs. These programming test is basically for checking the mathematical knowledge and Java operator precedence to implement these formulae.

1. Program to calculate the area of rectangle
Input: Width = 10; Height = 5
Output:
Area of Rectangle = Width * Height
= 10 * 5
= 50
2. Program to calculate the volume of sphere
Input:Radius = 48; Pie = 3.14
Output:
= (4.0/3.0) * 3.14 * 48 * 48 * 48
= 463433.132812
3. Program find the area of the pentagon
Input:s = 13; a = 5;
Output:
Area of Pentagon = (5.0/2.0) * s * a
= (5.0/2.0) * 13 * 5
= 162.5
4. Program to find the area of parallelogram
Input:base = 4; height = 18;
Output:
Area of Parallelogram = base * height;
= 4 * 18
= 72
5. Program to find the area of square
Input:a = 13
Output:
Area of Square = a2
= 132
= 169
6. Program to find the surface area of sphere
Input:Radius = 37, Pie = 3.14
Output:
= 4 * 3.14 * 37 * 37
= 17210.285714
7. Program to find the volume of cone
Input:Radius = 38, Height = 35, Pie = 3.14
Output:
= 3.14 * 38 * 38 * 35/3
= 48766.666667
8. Program to find the volume of the cube
Input:side = 4
Output:
Volume of cube = side3
= 43
= 64
9. Program to find the volume of cylinder
Input:radius (r) = 38 , height (h) = 35
Output:
Volume of the cylinder = pie * radius2 * height
= 3.14 * 38* 38 * 35
= 146300.000000
10. Program to calculate the CGPA percentage
CGPA percentage is = (float)(9.5 * (CGPA));
Input:
CGPA = (Grades in all Subjects) / (Total Number of Subjects).
English = 9.1;
Hindi = 8.5;
Maths = 9.5;
Science =9.6;
SocialStudy = 8.6;
CGPA = (9.1+8.5+9.5+9.6+8.6)/(5.0);
Output:CGPA percentage is = 86.070000
11. Program to convert Celsius into Fahrenheit
Temperature in Fahrenheit = ((celsius * 9) / 5) + 32
Input:celsius= 12
Output:Temperature in Fahrenheit = 53.6
12. Program to convert days into years
Input:days= 799;
Output:
Number of years = days / 365;
= 799 / 365
= 2
13. Program to convert Fahrenheit into Celsius
Temperature in Celsius = ((Fahrenheit-32)*5)/9
Input:Fahrenheit = 54
Output:Temperature in Celsius= ((54-32)*5)/9 = 12.22222
14. Program to find the area of an equilateral triangle
Input:side (a) = 5
Output:
Area of Equilateral Triangle = ( 1.73 * a * a) / 4
= ( 1.73 * 5 * 5) / 4
= 10.81250
15. Program to find the area of a triangle
Input:b = 5; h = 12
Output:Area of Triangle = (b * h) / 2
= (5 * 12) / 2
= 30.0
16. Program to find the area of the right angle triangle
Input:b = 5; h = 8
Output:Area of Triangle = (b * h) / 2
= (5 * 8) / 2
= 20.0
17. Program to find the perimeter of the rectangle
Input:a = c = 5
b = d = 4
Output:Perimeter of Rectangle = 2 * ( a + b);
= 2 * (5 + 4)
= 18.00000
18. Program to find the simple interest
Simple Interest = (P × R × T) / 100
Input:P = 34000, R = 30,T = 5
where P = Principal Amount, R = Rate per Annum, T = Time (years)
Output: Simple Interest = 51000.000
19. Program to find the surface area of a cube
Surface Area Of Cube = 6 ( a * a )
Input:b = 5, h = 5
a (side) = length = breadth = height
Output:Surface Area Of Cube = 6 * 5 * 5=150.00000
20. Program to find the surface area of sphere
Input:l= 2, w = 3, h = 5;
where l = length, w = width and h = height.
Output:
Surface Area OfCuboid = 2 * (l * w+ w * h + h * l)
= 2 * (2 * 3 + 3 * 5 + 5 * 2)
= 62.00000
21. Program to find the surface area of the cylinder
Surface Area of Cylinder = 2 Π (r + h)
Input:r = 2.0, h = 5.0
Output:
Surface Area of Cylinder = 2 Π (r + h)
Here, r = radius, h = height, and Π ( pie ) = 3.14
= 2 * 3.14 * ( 2.0 + 5.0)
= 44.00000
22. Write a Java program to compute the area of a hexagon.
Area of a hexagon = (6 * s^2)/(4*tan(π/6))
where s is the length of a side
Input: Input the length of a side of the hexagon: 6
Output: The area of the hexagon is: 93.53074360871938
23. Write a Java program to compute the area of a polygon.
Area of a polygon = (n*s^2)/(4*tan(π/n))
where n is n-sided polygon and s is the length of a side
Input:
Input the number of sides on the polygon: 7
Input the length of one of the sides: 6
Output: The area is: 130.82084798405722
24. Write a Java program to compute the distance between two points on the surface of earth.
Distance between the two points [ (x1,y1) & (x2,y2)]
d = radius * arccos(sin(x1) * sin(x2) + cos(x1) * cos(x2) * cos(y1 – y2))
Radius of the earth r = 6371.01 Kilometers
Input:
Input the latitude of coordinate 1: 25
Input the longitude of coordinate 1: 35
Input the latitude of coordinate 2: 35.5
Input the longitude of coordinate 2: 25.5
Output: The distance between those points is: 1480.0848451069087 km

# Frequently Asked Algorithms & Java Programs

Below are most frequently asked algorithms and programs in interview to test interviewee programming and logical skill. These question can be asked with fresher and any senior level programmers to check hands on with the code or not.

1. Write a program to print alphabet using java loop
Output:
a b c d e f g h i j k l m n o p q r s t u v w x y z
a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
2. Write a program to check odd or even number.
Input:  5
Output: Odd Number
3. Write a program to convert Fahrenheit to Celsius.
Input: 50
Output: 10.0
4. Write a java program to print fibonacci series without using recursion and using recursion.
Input: 12
Output: 0 1 1 2 3 5 8 13 21 34 55 89 144
5. Write a java program to check prime number.
Input: 42
Output: Not prime number
Input: 13
Output: Prime number
6. Write a java program to check palindrome number.
Input: 349
Output: Not palindrome number
Input: 1234321
Output: Palindrome number
7. Write a java program to print factorial of a number.
Input: 4
Output: 24
Input: 5
Output: 120
8. Write a java program to check Armstrong number.
Input: 153
Output: Armstrong number
Input: 22
Output: Not Armstrong number
9. Write a program to swap numbers without using third variable.
Input: 20 30
Output: 30 20
10. Write a program to reverse of number.
Input:    123456
Output: 654321
11. Write a program to find largest of three numbers.
Input: 10 30 40
Output: 40
12. Write a program to print Floyd triangle.
Input: 7
Output:

`1`
`2 3`
`4 5 6`
`7 8 9 10`
`11 12 13 14 15`
`16 17 18 19 20 21`
`22 23 24 25 26 27 28`

# Sorting Program

1. Write a java program to sort an array elements using bubble sort algorithm.
Input:    2 6 3 8 4 1 5 0
Output: 0 1 2 3 4 5 6 8
2. Write a java program to sort an array elements using selection sort algorithm.
Input:    2 6 3 8 4 1 5 0
Output: 0 1 2 3 4 5 6 8
3. Write a java program to sort an array elements using insertion sort algorithm.
Input:    2 6 3 8 4 1 5 0
Output: 0 1 2 3 4 5 6 8
4. Write a java program to sort an array elements using quick sort algorithm.
Input:    12 24 45 56 10 9 49 30 5 15
Output: 5 9 10 12 15 24 30 45 49 56
5. Write a java program to sort an array elements using heap sort algorithm.
Input:    2 6 3 8 4 1 5 0
Output: 0 1 2 3 4 5 6 8
6. Write a java program to sort an array elements using merge sort algorithm.
Input:    12 24 45 56 10 9 49 30 5 15
Output: 5 9 10 12 15 24 30 45 49 56
7. Write a java program to sort an array elements using shell sort algorithm.
Input:    2 6 3 8 4 1 5 0
Output: 0 1 2 3 4 5 6 8
8. Write a java program to sort an array elements using radix sort algorithm.
Input:   170 45 75 90 2 802 2 66
Output: 2 2 45 66 75 90 170 802
9. Write a java program to sort an array elements using bucket sort algorithm.
Input:   0.23 0.67 0.32 0.25 0.88 0.45 0.86 0.16 0.59 0.38 0.19 0.43 0.02
Output: 0.02 0.16 0.19 0.23 0.25 0.32 0.38 0.43 0.45 0.59 0.67 0.86 0.88
10. Write a java program to sort an array elements using counting sort algorithm.
Input:    2 6 3 2 8 4 8 1 5 3 1 4 0
Output: 0 1 1 2 2 3 3 4 4  5 6 8 8

# Fibonacci Series Java Program

“A fibonacci series is sequence of numbers, where each number is sum of the two preceding two numbers, Series initial two values are 1 , 1″

For Example : 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144………

# Fibonacci Series Program

Here is program to get Fibonacci series number on particular position and print series up to that point. In this program using recursion to generate Fibonacci numbers, Here put base condition to terminate recursion as when number reach to 1 or 2  and for rest of the case work recursively for current number and previous one and then add it.

```import java.util.HashMap;
import java.util.Map;

public class FibonacciSeriesExample {

private static Map series = new HashMap();

public static void main(String[] args) {

// Get the 12th fibonacci number from series
System.out.println("Fibonacci 12 the position element :" + fibonacci(12));

System.out.println("Print Complete Fibonacci Series :");
printFibonacci(series);
}

public static int fibonacci(int fibIndex) {

// set base element of fibonacci series
if (fibIndex == 1 || fibIndex == 2) {
series.put(1, 1);
series.put(2, 1);
}

// execute fibonacci recursively until fibIndex reach to 1
if (series.containsKey(fibIndex)) {
return series.get(fibIndex);
} else {
int answer = fibonacci(fibIndex - 1) + fibonacci(fibIndex - 2);
}
}

public static void printFibonacci(Map series) {

for (Map.Entry entry : series.entrySet()) {
System.out.println(entry.getValue());
}
}
}

```

## Output

``````
Fabonnici 12 the position element :144
Print Complete Fabonni Series :
1
1
2
3
5
8
13
21
34
55
89
144

``````

# Merge Sort Program and Complexity (Big-O)

Mergesort is a comparison sort, same as quicksort and based on divide and conquer algorithm. It divides the original data set into smaller pieces of data set to solve the problem and then finally merge these small data sets.

## How Merge Sort Works

Merge sort works in the following way:

1. Merge sort, take middle index in data set and split into two collections : one collection for items left of middle index and second for right values of middle index.
2. Repeat step 1 as long as these collections size reach to one item only.
3. Now merge sort picks the items from smaller collections, sort them and merge to create new collection.
4. Repeat this sort and merge process until all small colection sort and merge not completed.
5. Finally will get single collection with sorted result.

## Points to Remember

• Data Structure: Array
• Best Time Complexity: Ω(n log(n))
• Average Time Complexity: Θ(n log(n))
• Worst Time Complexity: O(n log(n))
• Worst Space Complexity: O(n) ## Merge Sort Program

```public class MergeSort {

public int[] sort(int [] array){
mergeSort(array, 0, array.length-1);
return array;

}

private void mergeSort(int[] array, int first, int last) {

// Get mid position to divide problem into smaller size collections
int mid = (first + last) / 2;

//If first < last the array must be recursively sorted
if (first < last) {
mergeSort(array, first, mid);
mergeSort(array, mid + 1, last);
}

//merge solved collections to get solution to original problem
int a = 0, f = first, l = mid + 1;
int[] temp = new int[last - first + 1];

//decide the swapping of items
while (f <= mid && l <= last) {
temp[a++] = array[f] < array[l] ? array[f++] : array[l++];
}

while (f <= mid) {
temp[a++] = array[f++];
}

while (l <= last) {
temp[a++] = array[l++];
}

a = 0;
while (first <= last) {
array[first++] = temp[a++];
}
}

public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}

}

public static void main(String[] args) {

System.out.println("Original array before Merge sort");
int[] items = {12, 24, 45, 56, 10, 9, 49, 30, 5, 15};
printArray(items);

System.out.println("\n\nAfter Mergesort");
MergeSort merge = new MergeSort();
merge.sort(items);
printArray(items);

}
}
```

## Output

``````
Original array before Merge sort
12 24 45 56 10 9 49 30 5 15

After Mergesort
5 9 10 12 15 24 30 45 49 56
``````

# Quicksort Program and Complexity (Big-O)

Quicksort is a comparison sort based on divide and conquer algorithm. Quick sort is more fast in comparison to Merge Sort ot Heap Sort. It’s not required additional space for sorting.

## How Quick Sort Works

The idea to implement Quicksort is first divides a large array into two smaller sub-arrays as the low elements and the high elements then recursively sort the sub-arrays.

The above process follow below steps:

1. If array having 0 or 1 item then it’s already sorted.
2. Pick an item from the array that is called as pivot.
3. Partition this array as items less than pivot will come before pivot while items greater than pivot will come after it (equals values can either way). Now Pivot get it’s exact position.
4. Now repeat step 2 and 3 for both left and right side values of Pivot and continue same as long as no left or right items remaining.
5. Finally, as result of array will sorted items. ## Points to remember

• Data Structure: Array
• Best Time Complexity: Ω(n log(n))
• Time Complexity: Θ(n log(n))
• Worst Time Complexity: O(n^2)
• Worst Space Complexity: O(log(n))

## Quick Sort Program

```public class QuickSort {

public void quicksort(int[] array) {
quicksort(array, 0, array.length - 1);
}

private void quicksort(int[] array, int first, int last) {
if (first < last) {
int pivot = partition(array, first, last);

// Recursive call
quicksort(array, first, pivot - 1);
quicksort(array, pivot + 1, last);
}
}

private int partition(int[] input, int first, int last) {

//choose pivot as last item
int pivot = last;

swap(input, pivot, last);
for (int i = first; i < last; i++) {
if (input[i] <= input[last]) {
swap(input, i, first);
first++;
}
}

swap(input, first, last);
return first;
}

private void swap(int[] input, int a, int b) {
int temp = input[a];
input[a] = input[b];
input[b] = temp;
}

public static void printArray(int[] items) {
for (int i = 0; i < items.length; i++) {
System.out.print(items[i] + " ");
}
}

public static void main(String[] args) {

int[] items = {12, 24, 45, 56, 10, 9, 49, 30, 5, 15};
System.out.println("Original Array Before Quick Sort");
printArray(items);

System.out.println("\n\nAfter QuickSort");

QuickSort sort = new QuickSort();
sort.quicksort(items);
printArray(items);

}
}
```

## Output

``````
Original Array Before Quick Sort
12 24 45 56 10 9 49 30 5 15

After QuickSort
5 9 10 12 15 24 30 45 49 56
``````

# Radix Sort Program and Complexity (Big-O)

Radixsort sorts numeric data (integers or float) by considering a string of numbers where digit by digit sort starting from least significant digit position to most significant digit position. To sort these specific positions data counting sort as a subroutine.

Counting sort is a linear time sorting algorithm that sort in O(n+k) but that will worst in case of items range from 1 to n2 that sort in O(n^2). Where K is items range from 1 to k.

Note :

• LSD : Least Significant Digit
• MSD : Most Significant Digit

1. Check for the max length item in input values and check for length.
2. For each digit position i where i varies from LSD to the MSD.
3. Perform counting sort based on considering key as i position digits.
4. Finally, you will get a sorting array for input items.

## Points to Remember

• Data Structure: Array
• Best Time Complexity: Ω(nk)
• Average Time Complexity: Θ(nk)
• Worst Time Complexity: O(nk)
• Worst Space Complexity: O(n+k)

``````
Input Numbers:

170, 45, 75, 90, 02, 802, 2, 66
Step 1 : Find the max item length in input i.e 3.

Step 2: Repeat the below process for position i from LSD to MSD
Perform count sort on numbers, after considering digits as key on
particular i.

0 Position :
170, 90, 02, 802, 2, 45, 75, 66

1 Position :
02, 2, 802, 45, 66, 170, 75, 90

2 Position :
02, 2, 45, 66, 75, 90, 170, 802

Step 3: Final Redix Sort result

02, 2, 45, 66, 75, 90, 170, 802

``````

```public class RadixSort {

public static void main(String[] args) {

// Assuming our key values are with in range 0 - 9
int[] items = { 170, 45, 75, 90, 02, 802, 2, 66 };
printArray(items);

// Perform counting sort sort

printArray(items);
}

// radix sort method to sort values of array items
// find max number to know max number of digits
int m = getMax(items);

// Perform counting sort for every digit. Note that instead
// of passing digit number, exp is passed. exp is 10^i
// where i is current digit number
for (int exp = 1; m / exp > 0; exp *= 10)
countingsort(items, exp);
}

// A utility method to get maximum value in items[]
static int getMax(int items[]) {
int max = items;
for (int i = 1; i  max)
max = items[i];
return max;
}

private static void countingsort(int[] items, int exp) {
// create array of size 10 that will have index value as 0-9
// it will create array of size 10 and initialize
// each element with value 0
int[] counts = new int;
int[] output = new int[items.length];
for (int key : items) {
// for each match key, index position element
// increase count as 1
counts[(key / exp) % 10] += 1;
}

// Change count[i] so that count[i] now contains
// actual position of this digit in output[]
for (int i = 1; i = 0; i--) {
output[counts[(items[i] / exp) % 10] - 1] = items[i];
counts[(items[i] / exp) % 10] -= 1;
}

// Copy the output array to items[] to return
// sorted array according to index position
for (int i = 0; i < items.length; i++)
items[i] = output[i];

}

static void printArray(int items[]) {
for (int item : items) {
System.out.print(item + " ");
}
System.out.println();
}

}

```

## Output

``````
170 45 75 90 2 802 2 66
2 2 45 66 75 90 170 802
``````

# Bucket Sort Program and Complexity (Big-O)

Bucket sort/Bin sort is a distribution sort as a generalization of pigeonhole sort. It’s useful when input values are uniformly distributed over a range then divide this range in some interval and put values in a bucket which lies within these intervals.Finally, sort values in each bucket by any sorting technique and then print by sequence by iterating intervals.

## Bucket Sort Steps

1. Set up an array of empty “buckets” initially.
2. Go over the original array, putting each item in its interval bucket.
3. Sort all non-empty bucket.
4. Visit each interval buckets in order and put all elements back into the original array.

## Points to Remember

• Data structure: Array
• Best Time Complexity: Ω(n+k)
• Average Time Complexity: Θ(n+k)
• Worst Time Complexity: O(n^2)
• Worst Space Complexity: O(n)

## Bucket Sort Java Program

```public class BucketSort {

public static void main(String[] args) {

//Assuming our key values are with in range 0 - 1
double[] items = { 0.23, 0.67, 0.32, 0.25, 0.88, 0.45, 0.86, 0.16, 0.59, 0.38, 0.19, 0.43,  0.02 };
System.out.println("Before Bucket Sorting :");
printArray(items);

//Perform counting sort sort
bucketsort(items);

System.out.println("After Bucket Sorting :");
printArray(items);
}

private static void bucketsort(double []items)
{
//create array of size 10 that will have index value as 0-9
//Initially will keep empty bucket
java.util.List []numbers=new ArrayList;
for(double key:items)
{
//To equally distribute input values , multiply key with array size.
int index=(int)(key*numbers.length);
//index position is not having any value yet create blank bucket
if(numbers[index]==null)
{
numbers[index]=new ArrayList();

}
//add items based on index position
}

//Now sort values in each bucket by any sorting method
// and add in initial array
int i=0;
for(int index=0; index<span id="mce_SELREST_start" style="overflow:hidden;line-height:0;">&#65279;</span>&lt;numbers.length; index++)
{

if(numbers[index]!=null)
{
//Here i am using Collections utility method but
//you use any sorting algorithm.
Collections.sort(numbers[index]);
//iterate each value in sorted bucket
//add it in original array position
for(double  item:numbers[index])
{
items[i++]=item;
}
}

}
}

static void printArray(double items[])
{
for (double item:items)
{
System.out.print(item + &quot; &quot;);
}
System.out.println();
}

}
```

## Output

``````
Before Bucket Sorting :
0.23 0.67 0.32 0.25 0.88 0.45 0.86 0.16 0.59 0.38 0.19 0.43 0.02
After Bucket Sorting :
0.02 0.16 0.19 0.23 0.25 0.32 0.38 0.43 0.45 0.59 0.67 0.86 0.88
``````

# Shell Sort Program and Complexity (Big-O)

Shellsort is an in-place comparison sort, also known as Shell sort or Shell’s method. It’s mainly variation of insertion sort or bubble sort . There was one drawback with insertion sort, we move elements only one position ahead but when an elements are too far then lots of movements are involved. To reduce these movements Shell sort come with idea of allow exchange of far items.

## Shell Sort Steps

• Pick some far location h and make sorted array for values index[h…n-1] by insertion sort.
• Reduce the value of h until it becomes 1.
• Repeat the steps 1 and 2
• Finally you will get sorted items list.

## Points to Remember

• Data structure: Array
• Worst-case performance: O(n2) (worst known worst case gap sequence) O(n log2n) (best known worst case gap sequence)
• Best-case performance: O(n log n) (most gap sequences) O(n log2n)  (best known worst case gap sequence)
• Average performance: depends on gap sequence
• Worst-case space complexity : О(n) total, O(1) auxiliary

## Sell Sort Java Program

```public class ShellSort {
public static void main(String[] args)
{
int[] items = { 2, 6, 3, 8, 4, 1, 5, 0 };
System.out.println("Before Shell Sorting :");
printArray(items);

//Perform shell sort
shellsort(items);

System.out.println("After Shell Sorting :");
printArray(items);
}
static void shellsort(int items[])
{
int n = items.length;

// Start with a big gap, then reduce the gap until 1
for (int gap = n/2; gap > 0; gap /= 2)
{
//perform insertion sort for these gap size
//The first gap elements a[0..gap-1] are already
//in gapped order keep adding one more element
//until the entire array is gap sorted

for (int i = gap; i = gap && items[j - gap] > temp; j -= gap)
items[j] = items[j - gap];

// put temp in its correct  location
items[j] = temp;
}
}

}

static void printArray(int items[])
{
for (int item:items)
{
System.out.print(item + " ");
}
System.out.println();
}
}

```

## Output

``````
Before Shell Sorting :
2 6 3 8 4 1 5 0
After Shell Sorting :
0 1 2 3 4 5 6 8
``````

# Counting Sort program & Complexity (Big-O)

Counting sort also called an integer sorting algorithm. Counting sort algorithm is based on keys in a specific range. It counts the number of items for distinct key value, use these keys to determine position or indexing on the array and store respective counts for each key. Finally, sort values based on keys and make sequences the repetition of key based on counts.

Counting sort is suitable where variation in keys are is not significantly greater than the number of items. Its running time is linear as numbers of items(n)+difference between max and min key values.

## Points to Remember

• Data structure: Array
• Worst-case performance: O(n+k), where k is the range of the non-negative key values.
• Worst-case space complexity: O(n+k)

• Counting sort is a stable sort, where if two items have the same key, they should have the same relative position in the sorted output as they did in the input.

• Data range should be predefined, if not then addition loops required to get min and max value to get range.
• Not much variation on key values otherwise will occupy unnecessary space in the array.

## Steps for Counting Sort

``````
For easily understand, consider the data in the range 0 to 9 for below example:
Input data: 2, 6, 3, 2, 8, 4, 8, 1, 5, 3, 1, 4, 0
1) Create an array of size 10 (index values 0-9) and store the count of each
unique item.
Index:     0  1  2  3  4  5  6  7  8  9
Count:     1  2  2  2  2  1  1  0  2  0

2) Execute loop for each index for array and check counts are more than zero.
repeat the index/key value until count reach to zero. Store these values in
previous array and increase index position by one. Now sorted array

Index:     0  1  2  3  4  5  6  7  8  9 10   11 12
Count:     0  1  1  2  2  3  3  4  4  5  6   8  8

``````

## Counting Sort Program

```public class CountingSort {

public static void main(String[] args) {

//Assuming our key values are with in range 0 - 9
int[] items = { 2, 6, 3, 2, 8, 4, 8, 1, 5, 3, 1, 4, 0};
System.out.println("Before Counting Sorting :");
printArray(items);

//Perform counting sort sort
countingsort(items);

System.out.println("After Count Sorting :");
printArray(items);
}

private static void countingsort(int []items)
{
//create array of size 10 that will have index value as 0-9
//it will create array of size 10 and initialize
//each element with value 0
int []numbers=new int;
for(int key:items)
{
//for each match key, index position element
//increase count as 1
numbers[key]+=1;
}

//Now sort values based on keys and repeat
//this key value as per count
int i=0;
for(int key=0; key0)
{
for(int count=1;count<=numbers[key];count++)
{
items[i++]=key;
}
}

}
}

static void printArray(int items[])
{
for (int item:items)
{
System.out.print(item + " ");
}
System.out.println();
}

}
```

## Output

``````
Before Counting Sorting :
2 6 3 2 8 4 8 1 5 3 1 4 0
After Count Sorting :
0 1 1 2 2 3 3 4 4 5 6 8 8
``````

# Heapsort Program and Complexity (Big-O)

Heapsort is a sorting algorithm based on a Binary Heap data structure. It’s a comparison-based sorting similar to Selection Sort where first find maximum item and place that maximum item at the end. Repeat the same steps for remaining items until all items sorted.

## Points to Remember

• Data structure: Array
• Worst-case performance: O(n\log n)
• Best-case performance : O(n\log n) (distinct keys) O(n) (equal keys)
• Average performance: O(n\log n)
• Worst-case space complexity: O(n) total O(1) auxiliary

• Heapsort is a more favorable in worst-case O(n log n) runtime.

• Heapsort slower in practice on most machines than a well-implemented quicksort.
• Heapsort is not a stable sort but in-place algorithm.

## Binary Heap Data Structure

Binary Heap is a type of Complete Binary Tree where items stored such a way like a parent node value is greater than the values of its child nodes. That is also called as Max heap. it can be represented in the form of a binary tree or array.

### Binary Tree Representation in Array

To represent binary tree structure in the array, consider each array index as a node, where these index of nodes for a parent, left the child and right child follow these expression. In Binary tree for zero-based array ,the root node is stored at index 0; if i is the index of the current node, then

• parent(i) = floor((i-1) / 2) , where floor map a real number to the smallest leading integer.
• LeftChild(i) = 2*i + 1
• RightChild(i) = 2*i + 2

## Steps for Heap Sort

1. Call the heapify() function on the array to make as Max Heap Binary Tree array where Maximum item on the first position.
2. Swap the first item of the array with the final item. Consider the size of the array by decrease one. Call heapify() on the root of a binary tree.
3. Repeat the above steps until the size of the unsorted heap is 1.

Note: The heapify() operation is run once, and is O(n) in performance. The swapping() function is O(log n) and is called n times. Therefore, the total performance of this heap sort algorithm is O(n + n log n) = O(n log n).

```<h2>Heapsort Java Program</h2>
public class HeapSort {

public static void main(String []args)
{
int[] items = { 2, 6, 3, 8, 4, 1, 5, 0 };
System.out.println("Before Heap Sorting :");
printArray(items);

//Perform heap sort
heapsort(items);

System.out.println("After Heap Sorting :");
printArray(items);
}

public static void heapsort(int items[])
{
int itemCount = items.length;

// Build heap (rearrange array)
for (int i = itemCount / 2 - 1; i &gt;= 0; i--)
heapify(items, itemCount, i);

// One by one extract an element from heap
for (int i=itemCount-1; i&gt;=0; i--)
{
// Move max root item to end
int temp = items;
items = items[i];
items[i] = temp;

// call max heapify on the reduced heap
heapify(items, i, 0);
}
}

/**
* Call the heapify() function on the array of decrease size to make as Max Heap Binary
* Tree array where Maximum item on first position or root.
*/
static void heapify(int items[], int itemCount, int i)
{
int largest = i; // Initialize largest as root
int l = 2*i + 1; // left = 2*i + 1
int r = 2*i + 2; // right = 2*i + 2

// If left child is larger than root
if (l  items[largest])
largest = l;

// If right child is larger than largest so far
if (r  items[largest])
largest = r;

// If largest is not root
if (largest != i)
{
int swap = items[i];
items[i] = items[largest];
items[largest] = swap;

// Recursively heapify the affected sub tree
heapify(items, itemCount, largest);
}
}

static void printArray(int items[])
{
for (int item:items)
{
System.out.print(item + " ");
}
System.out.println();
}
}
```

## Output

``````
Before Heap Sorting :
2 6 3 8 4 1 5 0
After Heap Sorting :
0 1 2 3 4 5 6 8
``````

# Data Structure and Algorithms Complexity (Big-O)

Big-O notation is a mathematical representation used to describe the complexity of a data structure and algorithm. There are two types of Complexity :

1. Time Complexity: Its measure based on steps need to follow for an algorithm.
2. Space Complexity: It measures the space required to perform an algorithm and data structure.

## Data Structure and Algorithm Decision

Data structure and algorithm decisions are based on the complexity of size and operations need to perform on data. Some algorithms perform better on a small set of data while others perform better for big data sets for certain operations.

These days Space Complexity is not big concerns but the main performance of an algorithm measures based on time complexity. We can make the decision to choose an algorithm based on below performance criteria with respect to Complexity.

 Complexity Performance O(1) Excellent O(log(n)) Good O(n) Fair O(n log(n)) Bad O(n^2) Horrible O(2^n) Horrible O(n!) Horrible

This post almost covers data structure and algorithms space and time Big-O complexities. Here you can also see time complexities for types of operations like access, search, insertion, and deletion.

## Data Structure Space and Time Complexity

 Data Structure Time Complexity Space Complexity Average Worst Access Search Insertion Deletion Array Θ(1) Θ(n) Θ(n) Θ(n) O(n) Stack Θ(n) Θ(n) Θ(1) Θ(1) O(n) Queue Θ(n) Θ(n) Θ(1) Θ(1) O(n) Singly-Linked List Θ(n) Θ(n) Θ(1) Θ(1) O(n) Doubly-Linked List Θ(n) Θ(n) Θ(1) Θ(1) O(n) Skip List Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n log(n)) Hash Table N/A Θ(1) Θ(1) Θ(1) O(n) Binary Search Tree Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n) Cartesian Tree N/A Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n) B-Tree Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n) Red-Black Tree Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n) Splay Tree N/A Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n) AVL Tree Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n) KD Tree Θ(log(n)) Θ(log(n)) Θ(log(n)) Θ(log(n)) O(n)

## Sorting Algorithms Space and Time Complexity

 Algorithm Time Complexity Space Complexity Best Average Worst Worst Quick Sort Ω(n log(n)) Θ(n log(n)) O(n^2) O(log(n)) Merge Sort Ω(n log(n)) Θ(n log(n)) O(n log(n)) O(n) Tim Sort Ω(n) Θ(n log(n)) O(n log(n)) O(n) Heap Sort Ω(n log(n)) Θ(n log(n)) O(n log(n)) O(1) Bubble Sort Ω(n) Θ(n^2) O(n^2) O(1) Insertion Sort Ω(n) Θ(n^2) O(n^2) O(1) Selection Sort Ω(n^2) Θ(n^2) O(n^2) O(1) Tree Sort Ω(n log(n)) Θ(n log(n)) O(n^2) O(n) Shell Sort Ω(n log(n)) Θ(n(log(n))^2) O(n(log(n))^2) O(1) Bucket Sort Ω(n+k) Θ(n+k) O(n^2) O(n) Radix Sort Ω(nk) Θ(nk) O(nk) O(n+k) Counting Sort Ω(n+k) Θ(n+k) O(n+k) O(k) Cube Sort Ω(n) Θ(n log(n)) O(n log(n)) O(n)

# Selection Sort Program and Complexity (Big-O)

Selection sort is a simple sorting algorithm, it’s also known as in-place comparison sort. In selection sort algorithm, sorts an array of items by repeatedly finding the minimum item from unsorted part of array and move it at the beginning. This algorithm considers two sub arrays in a given array.

1. The sub array of already sorted items.
2. Remaining sub array unsorted items.

## Points to remember

• Data structure: Array
• Worst-case performance : О(n2) comparisons and O(n)swaps
• Best-case performance : O(n2) comparisons and O(n) Swaps
• Average performance: О(n2) comparisons and O(n) Swaps
• Worst-case space complexity :О(n) total, O(1) auxiliary

• Simple Implementation and efficient for small data set.
• Efficient in  comparison to other Quadratic Sort (i.e O(n2)) like Bubble Sort or  Insertion Sort.
• Efficient for data set that are already sorted. Time Complexity ( i.e O(n))
• Not change relative order of elements which are already sorted. Space Complexity (i.e O(1))

• Selection sort is much less efficient on large lists in compare to algorithms such as quicksort, heapsort, or merge sort.

## Selection Sort Steps

Here * marks the value set on particular iteration.

 2 6 3 8 4 1 5 0 0* 6 3 8 4 1 5 2 0 1* 3 8 4 6 5 2 0 1 2* 8 4 6 5 3 0 1 2 3* 4 6 5 8 0 1 2 3 4* 6 5 8 0 1 2 3 4 5* 6 8 0 1 2 3 4 5 6* 8

## Selection Sort with Loop

```public class SelectionSort {
public static void main(String[] args) {
int[] items = { 2, 6, 3, 8, 4, 1, 5, 0 };
System.out.println("Before Selection Sorting :");
printArray(items);

// Perform selection sort
selectionSort(items);

System.out.println("After Selection Sorting :");
printArray(items);
}

static void selectionSort(int items[]) {

// select item one by one based on index
for (int i = 0; i < items.length - 1; i++) {
// Find the minimum item in unsorted array
int min_idx = i;
for (int j = i + 1; j < items.length; j++)
if (items[j] < items[min_idx])
min_idx = j;

// Swap the found minimum selected item with
// the first selected item
int temp = items[min_idx];
items[min_idx] = items[i];
items[i] = temp;
}
}

static void printArray(int items[]) {
for (int item : items) {
System.out.print(item + " ");
}
System.out.println();
}
}
```

## Output

``````
Before Insertion Sorting :
2 6 3 8 4 1 5 0
After Insertion Sorting :
0 1 2 3 4 5 6 8
``````

# Insertion Sort Program and Complexity (Big-O)

Insertion sort is a simple sorting algorithm, which consumes one input item for each repetition, and grow a sorted output list. In every iteration, removes one item from input data, find the exact location in the sorted list and inserts it there. This process will repeat as long as no input items remain.

## Points to remember

• Data structure :  Array
• Worst-case performance : О(n2) comparisons and swaps
• Best-case performance : O(n) comparisons, O(1) swaps
• Average performance: О(n2) comparisons and swaps
• Worst-case space complexity : О(n) total, O(1) auxiliary

• Simple Implementation and efficient for small data set.
• Not change relative order of elements which are already sorted
• Efficient in comparison to other Quadratic Sort (i.e O(n2)) like Bubble Sort or Selection Sort.
• Efficient for data set that are already sorted. Time Complexity( i.e O(n)).
• Only required constant amount of memory space , as size of data set. Space
Complexity (i.e O(1))

• Insertion sort is much less efficient on large lists in compare to algorithms such as quicksort, heapsort, or merge sort.

## Insertion Sort Steps

Here * marks the value set on particular iteration.

 2 6 3 8 4 1 5 0 2 6* 3 8 4 1 5 0 2 3* 6 8 4 1 5 0 2 3 6 8* 4 1 5 0 2 3 4* 6 8 1 5 0 1* 2 3 4 6 8 5 0 1 2 3 4 5* 6 8 0 0* 1 2 3 4 5 6 8

In following programs you will learn both the ways to implement Insertion Sort by For Loop and Recursion.

## Insertion Sort with Loop

```public class InsertionSort {
public static void main(String[] args) {
int[] items = { 2, 6, 3, 8, 4, 1, 5, 0 };
System.out.println("Before Sorting :");
printArrayTR(items);

//Perform insertion sort
insertionSort(items);

System.out.println("After Sorting :");
printArray(items);
}

static void insertionSort(int items[])
{
int n = items.length;
for (int i = 1; i = 0 && items[j] > key) {
items[j + 1] = items[j];
j = j - 1;
}
items[j + 1] = key;
printArrayTR(items);
}

}
static void printArray(int items[])
{
for (int item:items)
{
System.out.print(item + " ");
}
System.out.println();
}
}
```

## Output

``````
Before Insertion Sorting :
2 6 3 8 4 1 5 0
After Insertion Sorting :
0 1 2 3 4 5 6 8
``````

## Insertion Sort with Recursion

```public class InsertionSortRecursion {
public static void main(String[] args) {
int[] items = { 2, 6, 3, 8, 4, 1, 5, 0 };
System.out.println("Before Insertion Sorting :");
printArray(items);

//Perform insertion sort
insertionSort(items,items.length);

System.out.println("After Insertion Sorting :");
printArray(items);
}

static void insertionSort(int items[],int n)
{
//base case or termination condition
if(n= 0 && items[j] > last)
{
items[j+1] = items[j];
j--;
}
items[j+1] = last;
}

static void printArray(int items[])
{
for (int item:items)
{
System.out.print(item + " ");
}
System.out.println();
}
}
```

## Output

``````
Before Insertion Sorting :
2 6 3 8 4 1 5 0
After Insertion Sorting :
0 1 2 3 4 5 6 8
``````

# JAVA : Generate 15 Minute Time Interval AM/PM

In this program you can get list of in time interval with fixed difference Ex: 15 minute in AM and PM format.

Example

```import java.util.ArrayList;
import java.util.List;

public class GenerateTimeInterval {

public static void main(String[] args) {
int interval = 15; //minutes interval
List timesList=new ArrayList() ; // time array
String []ap = {"AM", "PM"}; // AM-PM
String timeFormat;
for(int h=0;h<24;h++)
{
for(int m=0;m<60;)
{
if(h<12)
{
timeFormat=String.format("%02d:%02d %s", h,m,"AM");
}
else
{
timeFormat=String.format("%02d:%02d %s", h,m,"PM");
}
m=m+interval;
}

}
//To match the time
timeFormat=String.format("%02d:%02d %s", 0,0,"AM");
//print timings
for(String time : timesList)
{
System.out.println(time);
}

}
}

```

Output

``````
00:00 AM
00:15 AM
00:30 AM
00:45 AM
01:00 AM
01:15 AM
01:30 AM
01:45 AM
02:00 AM
02:15 AM
02:30 AM
02:45 AM
03:00 AM
03:15 AM
03:30 AM
03:45 AM
04:00 AM
04:15 AM
04:30 AM
04:45 AM
05:00 AM
05:15 AM
05:30 AM
05:45 AM
06:00 AM
06:15 AM
06:30 AM
06:45 AM
07:00 AM
07:15 AM
07:30 AM
07:45 AM
08:00 AM
08:15 AM
08:30 AM
08:45 AM
09:00 AM
09:15 AM
09:30 AM
09:45 AM
10:00 AM
10:15 AM
10:30 AM
10:45 AM
11:00 AM
11:15 AM
11:30 AM
11:45 AM
12:00 PM
12:15 PM
12:30 PM
12:45 PM
13:00 PM
13:15 PM
13:30 PM
13:45 PM
14:00 PM
14:15 PM
14:30 PM
14:45 PM
15:00 PM
15:15 PM
15:30 PM
15:45 PM
16:00 PM
16:15 PM
16:30 PM
16:45 PM
17:00 PM
17:15 PM
17:30 PM
17:45 PM
18:00 PM
18:15 PM
18:30 PM
18:45 PM
19:00 PM
19:15 PM
19:30 PM
19:45 PM
20:00 PM
20:15 PM
20:30 PM
20:45 PM
21:00 PM
21:15 PM
21:30 PM
21:45 PM
22:00 PM
22:15 PM
22:30 PM
22:45 PM
23:00 PM
23:15 PM
23:30 PM
23:45 PM
00:00 AM

``````

# Java : How to convert seconds to Time?

In this blog, you will learn to convert seconds to time. An hour has 60*60=3600 seconds and a minute has 60 seconds.

Example
In this example helps you to convert total seconds to time as (hour, minute an d second). To show as text String convert these these values to String.

```public class ConvertSecondToTime {

public static void main(String[] args) {
long time = 180500700;
ConvertSecondToTime ts = new ConvertSecondToTime();
System.out.println("Inserted Total Seconds :"+time);
System.out.println(ts.secondsToTimeString(time));
}

public static String secondsToTimeString(long time) {
int seconds = (int) (time % 60);
int minutes = (int) ((time / 60) % 60);
int hours = (int) ((time / 3600) % 24);
String secondsTxt = (seconds < 10 ? "0" : "") + seconds;
String minutesTxt = (minutes < 10 ? "0" : "") + minutes;
String hoursTxt = (hours < 10 ? "0" : "") + hours;
return new String("Converted Time :"+ hoursTxt + " Hour : " + minutesTxt + " Minute :" + secondsTxt + " Second");
}
}
```

Output

``````
Inserted Total Seconds :180500700
Converted Time :03 Hour : 05 Minute :00 Second

``````

# Java : Convert Decimal to Binary

In this blog, you will learn to convert decimal number into binary string. The java.lang package provides api’s to convert a decimal number into a binary number.

Example
This program takes a decimal number from user as string and convert it to decimal number. toBinaryString() method takes an integer type value and returns its string representation of integer values which represents the data in binary. The base of binary number is 2.

```import java.util.Scanner;

public class ConvertDecimalToBinary {

public static void main(String[] args) {
Scanner scan = new Scanner(System.in);

System.out.println("Enter the decimal value:");
String hex = scan.nextLine();
// convert String to Int
int i = Integer.parseInt(hex);
// convert integer to binary
String by = Integer.toBinaryString(i);
// print binary String
System.out.println("Binary: " + by);
}
}
```

Output

``````
Enter the decimal value:
12
Binary: 1100

Enter the decimal value:
200
Binary: 11001000
``````

# Java : How to convert GMT, CST, IST and PST timezone?

In this article, you will learn to convert a date to GMT, CST, EST and PST format.

• GMT : Greenwich Mean Time
• CST : Central Standard Time= GMT-5
• EST : Eastern Standard Time = GMT-6
• PST : Pacific Standard Time=GMT-7

Example
This example helps you in converting a date to  GMT, CST, EST and PST time on the console. The SimpleDateFormat() constructor uses the given pattern and date format symbols. Here we use the date format as gmtFormat for date format in GMT timezone same way can convert for CST, EST and PST. Then we have used getTimeZone() method to get the time of both the zones to be converted.

```import java.util.*;
import java.text.*;

public class ConvertTimeZoneFromGMT {

public static void main(String[] args) {
//Current Date and Time
Date date = new Date();

//GMT Format
DateFormat gmtFormat = new SimpleDateFormat();
TimeZone gmtTime = TimeZone.getTimeZone("GMT");
gmtFormat.setTimeZone(gmtTime);
System.out.println("GMT Time: " + gmtFormat.format(date));

//CST Time
DateFormat cstFormat = new SimpleDateFormat();
TimeZone cstTime = TimeZone.getTimeZone("CST");
cstFormat.setTimeZone(cstTime);
System.out.println("CST Time: " + cstFormat.format(date));

//EST Time
DateFormat istFormat = new SimpleDateFormat();
TimeZone estTime = TimeZone.getTimeZone("EST");
estFormat.setTimeZone(estTime);
System.out.println("EST Time: " + estFormat.format(date));

// PST Time
DateFormat pstFormat = new SimpleDateFormat();
TimeZone pstTime = TimeZone.getTimeZone("PST");
pstFormat.setTimeZone(pstTime);
System.out.println("PST Time: " + pstFormat.format(date));

}
}
```

Output

``````
GMT Time: 3/22/19 8:39 AM
CST Time: 3/22/19 3:39 AM
EST Time: 3/22/19 2:09 PM
PST Time: 3/22/19 1:39 AM
``````

# Java Program : Convert Time Hour, Minute and Second

In this program converting one time unit value to hour, minute and second. Generally such type of questions asked in interview to check programming logic.

```import java.util.Scanner;

public class TimeConversion {
static int SECOND = 60*60;
static int MINUTE = 60;
static int HOUR = 1;

public static void main(String[] args) {

System.out.println("Please enter :\nh for hour\nm for minute \ns for second");
Scanner in = new Scanner(System.in);
System.out.println("Convert from:");
String fromUnit = in.nextLine();
System.out.println("Value:");
int val = in.nextInt();
String convertedTime = convertTime(fromUnit,val);
System.out.println("Converted Time :"+convertedTime);
}

private static String convertTime(String unit, int value)
{
int h=0,m=0,s=0,seconds=0;
//Convert to seconds
switch(unit)
{
case "h": seconds=value*SECOND;
break;
case "m": seconds=value*MINUTE;
break;
case "s": seconds=value;
break;
}

h=seconds/SECOND;
value=seconds%SECOND;

m=value/MINUTE;
value=value%MINUTE;

s=value/SECOND;

return h+" Hour "+m+" Minute "+s+" Second";
}
}
```

## Output

``````
h for hour
m for minute
s for second
Convert from:
m
Value:
60
Converted Time :1 Hour 0 Minute 0 Second

``````

# Java Program: How to convert Units?

In this program you will see, way to convert one length measuring unit to another unit.Generally such type of questions asked to check programming logics.

See Also : Java Program : Convert time hour minute and seconds

## Example

```import java.util.Scanner;

public class UnitConversionCalculator {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);

System.out.println("Convert from:");
String fromUnit = in.nextLine();
UnitConverter from = new UnitConverter(fromUnit);

System.out.println("Convert to: ");
String toUnit = in.nextLine();
UnitConverter to = new UnitConverter(toUnit);

System.out.println("Value:");
double val = in.nextDouble();
//convert to meter
double meters = from.toMeters(val);
//convert meter to required unit
double converted = to.fromMeters(meters);

System.out.println(val + " " + fromUnit + " = " + converted + " " + toUnit);
}

}

That is main class for unit conversion for length measurement.
public class UnitConverter {
static double INCHES = 39.37;
static double FEET = 3.28;
static double MILES = 0.00062;
static double MILLIMETERS = 1000;
static double CENTIMETERS = 100;
static double METERS = 1;
static double KILOMETERS = 0.001;

private double meters, converted;

String fromUnit, toUnit;

public UnitConverter(String afromUnit) {
fromUnit = afromUnit;
toUnit = afromUnit;
}

// method to convert given value to meter
public double toMeters(double val) {
if (toUnit.equals("in")) {
meters = (val / INCHES);
} else if (toUnit.equals("ft")) {
meters = (val / FEET);
} else if (toUnit.equals("mi")) {
meters = (val / MILES);
} else if (toUnit.equals("mm")) {
meters = (val / MILLIMETERS);
} else if (toUnit.equals("cm")) {
meters = (val/ CENTIMETERS);
} else if (toUnit.equals("m")) {
meters = (val / METERS);
} else {
meters = (val / KILOMETERS);
}
return meters;
}

// method to convert meter to required unit
public double fromMeters(double meters) {
if (fromUnit.equals("in")) {
converted = Math.round(INCHES * 100 * meters);
} else if (fromUnit.equals("ft")) {
converted = Math.round(FEET * 100 * meters);
} else if (fromUnit.equals("mi")) {
converted = Math.round(MILES * 100 * meters);
} else if (fromUnit.equals("mm")) {
converted = Math.round(MILLIMETERS * 100 * meters);
} else if (fromUnit.equals("cm")) {
converted = Math.round(CENTIMETERS * meters);
} else if (fromUnit.equals("m")) {
converted = Math.round(METERS * meters);
} else {
converted = Math.round(KILOMETERS * meters);
}
return converted;
}
}

Output
```
Convert from:
m
Convert to:
cm
Value:
1
1.0 m = 100.0 cm
```

# Java : How to remove duplicate elements from List?

Here you will see way to remove duplicate from ArrayList. I am using HashSet because it keeps unique values only.

See Also : Java : How to remove duplicate objects from List

Example

```import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class RemoveDuplicateElements {
public static void main(String[] args) {
ListstrList=new ArrayList();
//duplicate

System.out.println("==========Before Duplicate Remove :"+strList.size());
for(String str:strList)
System.out.println(str);

//Convert ArrayList to HashSet
Set set=new HashSet(strList);
//Convert HashSet to ArrayList
strList=new ArrayList(set);

System.out.println("==========After Duplicate Remove :"+strList.size());
for(String str:strList)
System.out.println(str);
}
}

```

Output

``````
==========Before Duplicate Remove :6
Facing
Issues
On
IT
Facing
IT
==========After Duplicate Remove :4
Facing
Issues
IT
On
``````

# Java : How to remove duplicate objects from List

In this below example list having duplicate object of AccountTransaction which need to remove from list. Here I am using HashSet because it always keep unique records. Now question comes how to decide uniqueness of object. As you know contract between hashcode() and equals() method deciding uniqueness and equality of object.

Here used Comparable interface to sort values based on transaction date.

hashcode() and equals() contract :

“If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result. If you only override equals() and not hashCode() your class violates this contract.”

Example

```
import java.math.BigDecimal;
import java.util.Date;

public class AccountTransaction implements Comparable{
private Date date;
String transactionType;
private String reference;
private BigDecimal amount;

public AccountTransaction(Date date, String transactionType, String reference, BigDecimal amount) {
super();
this.date = date;
this.transactionType = transactionType;
this.reference = reference;
this.amount = amount;
}
//Overriding toString() method to print object
@Override
public String toString() {
return "AccountTransactions [date=" + date + ", transactionType=" + transactionType + ", reference=" + reference
+ ", amount=" + amount + "]";
}
//Overriding hashcode() and equals() method to check equality and uniqueness
//of objects
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((amount == null) ? 0 : amount.hashCode());
result = prime * result + ((date == null) ? 0 : date.hashCode());
result = prime * result + ((reference == null) ? 0 : reference.hashCode());
result = prime * result + ((transactionType == null) ? 0 : transactionType.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
AccountTransaction other = (AccountTransaction) obj;
if (amount == null) {
if (other.amount != null)
return false;
} else if (!amount.equals(other.amount))
return false;
if (date == null) {
if (other.date != null)
return false;
} else if (!date.equals(other.date))
return false;
if (reference == null) {
if (other.reference != null)
return false;
} else if (!reference.equals(other.reference))
return false;
if (transactionType == null) {
if (other.transactionType != null)
return false;
} else if (!transactionType.equals(other.transactionType))
return false;
return true;
}
//Sort object by date
@Override
public int compareTo(AccountTransaction o) {

return this.getDate().compareTo(o.getDate());
}

//use getter and setter of properties
}

```

Here is the class having sample data which is having duplicate objects in list. calling removeDuplicate() method which is converting list to hashSet() to remove duplicate and then again converting to list then sorting by date.

```
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class RemoveDuplicateObjects {

public static void main(String[] args) {
List transactionList = new ArrayList();
try {
transactionList.add(new AccountTransaction(getDate("2018-10-15 10:50 AM"), "Account Debits", "Pizza hut",new BigDecimal("0.56")));
transactionList.add(new AccountTransaction(getDate("2018-10-15 10:52 AM"), "Account Debits", "Pizza hut",new BigDecimal("0.56")));
transactionList.add(new AccountTransaction(getDate("2018-10-15 10:48 AM"), "Account Debits", "Burger king",new BigDecimal("0.56")));
transactionList.add(new AccountTransaction(getDate("2018-10-15 10:38 AM"), "Account Debits", "Burger king",new BigDecimal("1.56")));
transactionList.add(new AccountTransaction(getDate("2018-10-15 10:55 AM"), "Account Debits", "Papa Johns",new BigDecimal("2.56")));
transactionList.add(new AccountTransaction(getDate("2018-10-15 10:35 AM"), "Account Debits", "Pizza hut",new BigDecimal("1.56")));
transactionList.add(new AccountTransaction(getDate("2018-10-15 10:35 AM"), "Account Credits", "Chase Bank",new BigDecimal("200")));
//Duplicate record
transactionList.add(new AccountTransaction(getDate("2018-10-15 10:52 AM"), "Account Debits", "Pizza hut",new BigDecimal("0.56")));
transactionList.add(new AccountTransaction(getDate("2018-10-15 10:38 AM"), "Account Debits", "Burger king",new BigDecimal("1.56")));
transactionList.add(new AccountTransaction(getDate("2018-10-15 10:35 AM"), "Account Credits", "Chase Bank",new BigDecimal("200")));

System.out.println("Transactions before removing duplicate=============");
for(AccountTransaction transaction:transactionList)
System.out.println(transaction);
System.out.println("Transactions after removing duplicate=============");
transactionList=removeDuplicate(transactionList);
for(AccountTransaction transaction:transactionList)
System.out.println(transaction);

} catch (Exception ex) {
ex.printStackTrace();
}
}

private static List removeDuplicate(List transactionList)
{
//Convert List to Set
Set transactionSet=new HashSet(transactionList);
//Convert Set to Array List
transactionList=new ArrayList(transactionSet);

//Sort object by transaction date and time
Collections.sort(transactionList);

return transactionList;
}

private static Date getDate(String dateStr) throws ParseException {
return new SimpleDateFormat("yyyy-MM-dd HH:mm a").parse(dateStr);
}
}

```

Output

``````
Transactions before removing duplicate=============
AccountTransactions [date=Mon Oct 15 10:50:00 IST 2018, transactionType=Account Debits, reference=Pizza hut, amount=0.56]
AccountTransactions [date=Mon Oct 15 10:52:00 IST 2018, transactionType=Account Debits, reference=Pizza hut, amount=0.56]
AccountTransactions [date=Mon Oct 15 10:48:00 IST 2018, transactionType=Account Debits, reference=Burger king, amount=0.56]
AccountTransactions [date=Mon Oct 15 10:38:00 IST 2018, transactionType=Account Debits, reference=Burger king, amount=1.56]
AccountTransactions [date=Mon Oct 15 10:55:00 IST 2018, transactionType=Account Debits, reference=Papa Johns, amount=2.56]
AccountTransactions [date=Mon Oct 15 10:35:00 IST 2018, transactionType=Account Debits, reference=Pizza hut, amount=1.56]
AccountTransactions [date=Mon Oct 15 10:35:00 IST 2018, transactionType=Account Credits, reference=Chase Bank, amount=200]
AccountTransactions [date=Mon Oct 15 10:52:00 IST 2018, transactionType=Account Debits, reference=Pizza hut, amount=0.56]
AccountTransactions [date=Mon Oct 15 10:38:00 IST 2018, transactionType=Account Debits, reference=Burger king, amount=1.56]
AccountTransactions [date=Mon Oct 15 10:35:00 IST 2018, transactionType=Account Credits, reference=Chase Bank, amount=200]
Transactions after removing duplicate=============
AccountTransactions [date=Mon Oct 15 10:35:00 IST 2018, transactionType=Account Credits, reference=Chase Bank, amount=200]
AccountTransactions [date=Mon Oct 15 10:35:00 IST 2018, transactionType=Account Debits, reference=Pizza hut, amount=1.56]
AccountTransactions [date=Mon Oct 15 10:38:00 IST 2018, transactionType=Account Debits, reference=Burger king, amount=1.56]
AccountTransactions [date=Mon Oct 15 10:48:00 IST 2018, transactionType=Account Debits, reference=Burger king, amount=0.56]
AccountTransactions [date=Mon Oct 15 10:50:00 IST 2018, transactionType=Account Debits, reference=Pizza hut, amount=0.56]
AccountTransactions [date=Mon Oct 15 10:52:00 IST 2018, transactionType=Account Debits, reference=Pizza hut, amount=0.56]
AccountTransactions [date=Mon Oct 15 10:55:00 IST 2018, transactionType=Account Debits, reference=Papa Johns, amount=2.56]
``````

# Linear Search Algorithm,Java Program and Complexity

Linear search also called sequential search is a way for finding a target value within a list. It sequentially checks each element from the list for the target value until a match is found or until all the elements have been searched.

## Algorithm

• Target value search start from the leftmost element of array[] and one by one compare target value with each element of array[]
• If target value matches with an element, return the index.
• If target value doesn’t match with any of elements, return -1.

## Complexity

• Best Case Performance O(1)
• Average Case Performance O(n)
• Worst Case Performance O(1)

Where O is BiG-O Notation and n is no of element in Array/List.

## Java Program for Linear Search of Element

```import java.util.Scanner;

class LinearSearch {
public static void main(String args[]) {
int c, n, targetValue, array[];

Scanner in = new Scanner(System.in);
System.out.println("Enter number of elements");
n = in.nextInt();
array = new int[n];

System.out.println("Enter " + n + " integers");

for (c = 0; c < n; c++)
array[c] = in.nextInt();

System.out.println("Enter target value to find");
targetValue = in.nextInt();

for (c = 0; c < n; c++) {
if (array[c] == targetValue)
{
System.out.println(targetValue + " is present at location " + (c + 1) + ".");
break;
}
}
if (c == n)
System.out.println(targetValue + " is not present in array.");
}
}

```

## Output

```Enter number of elements
10
Enter 10 integers
2
56
3
7
89
34
78
23
67
13
Enter target value to find
7
7 is present at location 4.

Enter number of elements
7
Enter 7 integers
12
45
34
78
23
87
90
Enter target value to find
32
32 is not present in array.

```

## More

For more DataStructure,Algorithms and Java Programing Test questions and sample code follow below links

# Ways to Read Input from Keyboard/User/Console by Java Program

Java Support 4 Ways of  read  input from keyboard:

• Scanner Class (In java.util package)
• DataInputStream (Java.io package)
• Console Class (Some IDE doesn’t support it For Example : Eclipse)

## How Data Accepts from Keyboard ?

For accepting data from keyboard by console we need three objects:

1. System.in

The data is received in the form of bytes from the keyboard by System.in which is an InputStream object.Then the InputStreamReader reads bytes and decodes them into characters.Then finally BufferedReader object reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.

Below Java Program showing all four ways of taking user input from console.

```package program.common;

import java.io.Console;
import java.io.DataInputStream;
import java.io.IOException;
import java.util.Scanner;

public class UserInputWays {

public static void main(String[] args) {
Way1ByScanner();
System.out.println("=====================================================");
System.out.println("=====================================================");
Way3ByDataStream();
System.out.println("=====================================================");
Way4ByConsole();
System.out.println("=====================================================");
}

private static void Way1ByScanner() {
System.out.println("Way 1 : By Scanner Class");
Scanner scan = new Scanner(System.in);

System.out.println("Enter a text string");
String s = scan.nextLine();
System.out.println("You entered text string " + s);

System.out.println("Enter an integer value");
int a = scan.nextInt();
System.out.println("You entered integer value " + a);

System.out.println("Enter a float value");
float b = scan.nextFloat();
System.out.println("You entered float value " + b);

}

try {
System.out.println("Enter a text string");
System.out.println("You entered text string " + s);

System.out.println("Enter an integer value");
System.out.println("You entered integer value " + a);

System.out.println("Enter a float value");
System.out.println("You entered float value " + b);

} catch (IOException ex) {
ex.printStackTrace();
}
}

private static void Way3ByDataStream() {
System.out.println("Way 3 : By DataStream");
try {
DataInputStream dis = new DataInputStream(System.in);

System.out.println("Enter a text string");
System.out.println("You entered text string " + s);

System.out.println("Enter an integer value");
System.out.println("You entered integer value " + a);

System.out.println("Enter a float value");
System.out.println("You entered float value " + b);
} catch (IOException ex) {
ex.printStackTrace();
}
}

/**
* Eclipse doesn't support Console Class to test that use command prompt
*/
private static void Way4ByConsole() {
System.out.println("Way 4 : By Console Class");
try
{
Console console = System.console();

System.out.println("Enter a text string");
System.out.println("You entered text string " + s);

System.out.println("Enter an integer value");
System.out.println("You entered integer value " + a);

System.out.println("Enter a float value");
System.out.println("You entered float value " + b);
}
catch(Exception ex)
{
ex.printStackTrace();
}
}

}

```

Output

```Way 1 : By Scanner Class
Enter a text string
saurabh Gupta
You entered text string saurabh Gupta
Enter an integer value
35
You entered integer value 35
Enter a float value
80.2
You entered float value 80.2
=====================================================
Enter a text string
Saurabh Gupta
You entered text string Saurabh Gupta
Enter an integer value
35
You entered integer value 35
Enter a float value
80.2
You entered float value 80.2
=====================================================
Way 3 : By DataStream
Enter a text string
Saurabh Gupta
You entered text string Saurabh Gupta
Enter an integer value
35
You entered integer value 859114762
Enter a float value
80.2
You entered float value 4.2004693E-5
=====================================================
Way 4 : By Console Class
Enter a text string
=====================================================
java.lang.NullPointerException
at program.common.UserInputWays.Way4ByConsole(UserInputWays.java:91)
at program.common.UserInputWays.main(UserInputWays.java:19)

```

## More

For more Algorithms and Java Programing Test questions and sample code follow below links

# Fahrenheit To Celsius Java Program

This program is to convert Fahrenheit to Celsius temperature based on user input value. Below is mathematical formula for conversion from Fahrenheit to Celsius temperature .

T = 9*T/5 + 32 where T is temperature on Celsius scale.

```import java.util.Scanner;

class FahrenheitToCelsius {
public static void main(String[] args) {
float temperatue;
Scanner in = new Scanner(System.in);

System.out.println("Enter Temperatue in Fahrenheit");
temperatue = in.nextInt();

temperatue = ((temperatue - 32)*5)/9;

System.out.println("Converted Temperatue in Celsius = " + temperatue);
}
}
```

Outout

```Enter Temperatue in Fahrenheit
100
Converted Temperatue in Celsius = 37.77778

Enter Temperatue in Fahrenheit
50
Converted Temperatue in Celsius = 10.0

Enter Temperatue in Fahrenheit
75
Converted Temperatue in Celsius = 23.88889
```

## More

For more Algorithms and Java Programing Test questions and sample code follow below links

# Floyd Triangle Java Program

This is Java Program to print Floyd triangle of continuous numbers based on inserted users numbers of rows.

```import java.util.Scanner;

class FloydTriangle
{
public static void main(String args[])
{
int n, num = 1, c, d;
Scanner in = new Scanner(System.in);

System.out.println("Enter the number of rows of floyd's triangle you want");
n = in.nextInt();

System.out.println("Floyd's triangle :-");

for ( c = 1 ; c <= n ; c++ )
{
for ( d = 1 ; d <= c ; d++ )
{
System.out.print(num+" ");
num++;
}

System.out.println();
}
}
}
```

output

```Enter the number of rows of floyd's triangle you want
7
Floyd's triangle :-
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19 20 21
22 23 24 25 26 27 28
```

## More

For more Algorithms and Java Programing Test questions and sample code follow below links

# Multiplication Table Java Program

This Java program is for print Multiplication table of Input Number.

```import java.util.Scanner;

class MultiplicationTable
{
public static void main(String args[])
{
int n, c;
System.out.println("Enter an integer value to display it's multiplication table");
Scanner in = new Scanner(System.in);
n = in.nextInt();
System.out.println("Multiplication table of "+n+" is :-");

for ( c = 1 ; c <= 10 ; c++ )
System.out.println(n+"*"+c+" = "+(n*c));
}
}
```

Output

```Enter an integer value to display it's multiplication table

13
Multiplication table of 13 is :-
13*1 = 13
13*2 = 26
13*3 = 39
13*4 = 52
13*5 = 65
13*6 = 78
13*7 = 91
13*8 = 104
13*9 = 117
13*10 = 130

```

## More

For more Algorithms and Java Programing Test questions and sample code follow below links

# Largest of Three Numbers

This java program is to easily find out largest number in three integers values. But that is not optimize way if numbers are more than that better follow other algorithms.

```lass LargestOfThreeNumbers {
public static void main(String args[]) {
int x, y, z;

Scanner in = new Scanner(System.in);
x = in.nextInt();
y = in.nextInt();
z = in.nextInt();

if (x > y && x > z)
System.out.println("First number is largest.");
else if (y > x && y > z)
System.out.println("Second number is largest.");
else if (z > x && z > y)
System.out.println("Third number is largest.");
else
System.out.println("Entered numbers are not distinct.");
}
}
```

Output

```Please Enter First integer
10
20
5
Second number is largest.
```

## More

For more Algorithms and Java Programing Test questions and sample code follow below links

# Palindrome Java Program

## Palindrome Definition

“A String is palindrome if it remains unchanged when reversed.”

“program” is not a palindrome. Some other palindrome strings are “nitin”,”mom”, “madam”, “abcba” etc.

Below is simple Java program to check input String is Palindrom or not.

```class Palindrome1 {
public static void main(String args[]) {
String original, reverse = "";
Scanner in = new Scanner(System.in);

System.out.println("Enter a string to check if it is a palindrome");
original = in.nextLine();

int length = original.length();

for (int i = length - 1; i >= 0; i--)
reverse = reverse + original.charAt(i);

if (original.equals(reverse))
System.out.println("Entered string is a palindrome.");
else
System.out.println("Entered string is not a palindrome.");

}
}
```

## Output

```Enter a string to check if it is a palindrome
nitin
Entered string is a palindrome.

Enter a string to check if it is a palindrome
Saurabh
Entered string is not a palindrome.

```

In above program you find out very simple way to check input string is palindrome but in below program you will see to check palindrome string with minimum number of operations because here dividing text in half size and compare with rest of part of String.

```import java.util.*;

class Palindrome2
{
public static void main(String args[])
{
String inputString;
Scanner in = new Scanner(System.in);

System.out.println("Enter a string to check if it is a palindrome");
inputString = in.nextLine();

int length  = inputString.length();
int i, begin, end, middle;

begin  = 0;
end    = length - 1;
middle = (begin + end)/2;

for (i = begin; i <= middle; i++) {
if (inputString.charAt(begin) == inputString.charAt(end)) {
begin++;
end--;
}
else {
break;
}
}
if (i == middle + 1) {
System.out.println("Entered string is a palindrome.");
}
else {
System.out.println("Entered string is not a palindrome.");
}
}
}
```

## Output

```Enter a string to check if it is a palindrome
nitin
Entered string is a palindrome.

Enter a string to check if it is a palindrome
Saurabh
Entered string is not a palindrome.

```

## More

For more Algorithms and Java Programing Test questions and sample code follow below links

# Prime Numbers Java program

## Prime Number Definition

“A whole number greater than 1 that is divisible only by itself and 1”.
A prime number will always have factors as 1 and itself. A factor is a whole numbers that can be divided evenly into another number. If Number is having more than two factors are called composite numbers.
The number 1 is neither prime nor a composite Number.
Smallest prime number is 2 and others are in sequence as 2,3,5,7,11,13,17,19,13,29  etc…

## Benefit

• prime numbers are very useful in cryptography.
• The mathematicians used prime numbers to develop new areas of mathematics, like number theory and knot theory, which developers use today.
This java program prints  number of prime numbers as required from the user.
```import java.util.*;

{
public static void main(String args[])
{
int n, status = 1, num = 3;

Scanner in = new Scanner(System.in);
System.out.println("Enter the number of prime numbers you want");
n = in.nextInt();

if (n &gt;= 1)
{
System.out.println("First "+n+" prime numbers are :-");
System.out.println(2);
}

for ( int count = 2 ; count &lt;=n ;  )
{
for ( int j = 2 ; j &lt;= Math.sqrt(num) ; j++ )
{
if ( num%j == 0 )
{
status = 0;
break;
}
}
if ( status != 0 )
{
System.out.println(num);
count++;
}
status = 1;
num++;
}
}
}
```

## Output

```Enter the number of prime numbers you want
5
First 5 prime numbers are :-
2
3
5
7
11
Enter the number of prime numbers you want

10
First 10 prime numbers are :-
2
3
5
7
11
13
17
19
23
29

```

## More

For more Algorithms and Java Programing Test questions and sample code follow below links

# Odd and Even Java Program

This java program finds if a number is odd or even.

If the number is divisible by 2 then it will be even, otherwise it is odd. We use Java modulus operator to find remainder in our program.

```class OddOrEvenNumber{
public static void main(String args[]) {<span 				data-mce-type="bookmark" 				id="mce_SELREST_start" 				data-mce-style="overflow:hidden;line-height:0" 				style="overflow:hidden;line-height:0" 			>﻿</span>
int x;
System.out.println("Enter an integer value to check if it is odd or even ");
Scanner in = new Scanner(System.in);
x = in.nextInt();

if (x % 2 == 0)
System.out.println("You entered an even number.");
else
System.out.println("You entered an odd number.");
}
}
```

Output

```Enter an integer value to check if it is odd or even
16
You entered an even number.

Enter an integer value to check if it is odd or even
125
You entered an odd number.
```

## More

For more Algorithms and Java Programing Test questions and sample code follow below links

# How to Reverse Number by Java Program?

Here in below program logic you will see how can be reverse number by using multiplication, reminder and division operations.

In this  below program follow steps for reverse number:

1. Reverse number initialize with zero.
2. Run loop till number of digits in insert number.
3. Take reminder of number by mod 10.
4. Add this reminder value with reverse number .
5. Multiply this reverse number with 10 .
6. Divide insert number by 10 and steps 2 to 6 repeat continuously.
```import java.util.Scanner;

class ReverseNumber
{
public static void main(String args[])
{
int n, reverse = 0;

System.out.println("Enter the integer number to reverse");
Scanner in = new Scanner(System.in);
n = in.nextInt();

while( n != 0 )
{
reverse = reverse * 10;
reverse = reverse + n%10;
n = n/10;
}

System.out.println("Reverse of entered integer number is "+reverse);
}
}
```

Output

```Enter the integer number to reverse
12345
Reverse of entered integer number is 54321

Enter the integer number to reverse

54535251
Reverse of entered integer number is 15253545
```

## More

For more Algorithms and Java Programing Test questions and sample code follow below links

# How to Prints Alphabets by Java Loops

Here you will see, How to prints Alphabets through Java all loops (for, While and do while). In these loops we are just increments char value and characters are increment continuously.

```public class PrintAlphabets {

public static void main(String[] args) {
// By for Loop
char ch;
for (ch = 'a'; ch <= 'z'; ch++) {
System.out.print(ch + " ");
}
System.out.println();

// By While loop
char c = 'a';

while (c <= 'z') {
System.out.print(c + " ");
c++;
}
System.out.println();

// By do while loop
c = 'A';

do {
System.out.print(c + " ");
c++;
} while (c <= 'Z');
}

}
```

Output

```a b c d e f g h i j k l m n o p q r s t u v w x y z
a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
```

## More

For more Algorithms and Java Programing Test questions and sample code follow below links

# How to Swap two Numbers with and with out temporary variable.

Here I will show you how you can swap two numbers A=20 and B=10 with and without temporary variables as A=10 and B=20.

## Swap Numbers with Temporary Variable

I will take one more temporary variable as temp to keep value of B so that during  copy of value A to B value of B is in temp and now we can copy value of temp to A. As below

temp=B       (This state : A=20, B=10, temp=10)

B=A;            (This state : A=20, B=20, temp=10)

A=temp      (This state : A=10, B=20, temp=10)

By applying above logic you can swap values of two variables. In below Java example I will implement same logic two swap numbers.

## Swap Numbers without Temporary Variable

There are two ways two swap two numbers without using any temporary variable.

Here you will see how to swap numbers A=20 and B=10 by using addition and subtraction operations.

A=A+B           (This state : A=30, B=10)

B=A-B           (This state : A=30, B=20)

A=A-B           (This state : A=10, B=20)

By applying above addition and subtraction logic you can swap values of two variables. In below Java example I will implement same logic two swap numbers.

### Multiplication and Division

Here you will see how to swap numbers A=20 and B=10 by using multiplication and division operations.

A=A*B           (This state : A=200, B=10)

B=A/B           (This state : A=200, B=20)

A=A/B           (This state : A=10, B=20)

By applying above multiplication and division logic you can swap values of two variables. In below Java example I will implement same logic two swap numbers.

## Swap Numbers Java Program

```package test;

import java.util.Scanner;

public class SwapNumbers {

public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
int A=scan.nextInt();

int B=scan.nextInt();

//swap Numbers with temporary variable
swapNumbersWithTemp(A,B);
//swap Numbers without temporary variable : Add and Sub
//swap Numbers without temporary variable : Mul and Div
swapNumbersWithoutTempMulDiv(A,B);
}

private static void swapNumbersWithTemp(int A, int B)
{
int temp=B;
B=A;
A=temp;

System.out.println("Numbers after swap with temporary variables");
System.out.println("A="+A+"and B="+B);
}

private static void swapNumbersWithoutTempAddSub(int A, int B)
{
A=A+B;
B=A-B;
A=A-B;

System.out.println("Numbers after swap without temporary variables: Add and Sub operation");
System.out.println("A="+A+"and B="+B);
}

private static void swapNumbersWithoutTempMulDiv(int A, int B)
{
A=A*B;
B=A/B;
A=A/B;

System.out.println("Numbers after swap without temporary variables: MUl and Div operation");
System.out.println("A="+A+"and B="+B);
}

}

```

## Output

```Please Enter First Number
20
10
Numbers after swap with temporary variables
A=10and B=20
Numbers after swap without temporary variables: Add and Sub operation
A=10and B=20
Numbers after swap without temporary variables: MUl and Div operation
A=10and B=20
<span 				data-mce-type="bookmark" 				id="mce_SELREST_start" 				data-mce-style="overflow:hidden;line-height:0" 				style="overflow:hidden;line-height:0" 			></span><span 			```