Programming Interview Questions

Only knowing the theoretical aspects of Java is not sufficient to crack the interview. One of the most important rounds for becoming a Java developer is the programming round, where the interviewee is asked to code. Writing optimized code is a must for becoming a Java developer. In this tutorial, we will discuss some advanced programming interview questions.

1) Given an integer array arr of size s. Now, check whether there exists at least one element which is strictly smaller than all the elements on the right of it and greater than all the elements on the left of it. If it exists, return true; otherwise, return false. Ignore the corner elements of the given array.

Example: 1

arr[] = {3, 4, 5, 1, 6, 10, 9, 7, 8}; s = 9

Ans: true

Explanation: All the numbers that are coming before 6 are smaller than 6, and all the elements that are coming after 6 are greater than 6. Hence, the answer is true.

Example: 2

arr[] = {4, 5, 1}; s = 3

Ans: false

Explanation: There is not a single number that fits the given condition. Hence, the answer is false.

FileName: PeakElement.java

// import statement
import java. util. Arrays;

public class PeakElement
{
boolean isPeak(int a[], int s)
{
boolean []l = new boolean[s];
boolean []r = new boolean[s];

int max = a[0];
l[0] = false;

// a loop to find those elements 
// that are greater than elements that are left of it
for (int j = 1; j < s; j++) 
{
if (a[j] > max) 
{
max = a[j];
l[j] = true;
} 
else 
{
l[j] = false;
}
}
int min = a[s - 1];
r[s - 1] = false;
for (int j = s - 2; j >= 0; j--) 
{

if (a[j] < min) 
{
r[j] = true;
min = a[j];
} 
else 
{
r[j] = false;
}
}

// a loop to find those elements 
// that are greater than elements that are right of it
for (int j = 0; j < s; j++) 
{
if (l[j] && r[j]) 
{
return true;
}
}
return false;
}
// main method
public static void main(String argvs[])
{
// creating an object of the class PeakElement
PeakElement obj = new PeakElement();

// input array 1
int arr[] = { 10, 2, 3, 4, 5, 4, 3, 2, 3, 10 };
int size = arr.length;

if(obj.isPeak(arr, size))
{
System.out.println("The array " + Arrays.toString(arr) + " has got a peak element.");
}
else
{
System.out.println("The array " + Arrays.toString(arr) + " has not got a peak element."); 
}

// input array 2
int arr1[] = {3, 4, 5, 1, 6, 10, 9, 7, 8}; 
size = arr1.length;

if(obj.isPeak(arr1, size))
{
System.out.println("The array " + Arrays.toString(arr1) + " has got a peak element.");
}
else
{
System.out.println("The array " + Arrays.toString(arr1) + " has not got a peak element."); 
}
}
}

Output:

The array [10, 2, 3, 4, 5, 4, 3, 2, 3, 10] has not got a peak element.
The array [3, 4, 5, 1, 6, 10, 9, 7, 8] has got a peak element.

2) Given a read-only array arr of size s, such that each element of the array can not exceed the value s. Also, in the array, each element occurs only once except a1, which is occurring twice, and therefore, a2 is missing. Find out the value of a1 and a2. Note that read-only means any modification in the input array is not allowed.

Example: 1

arr[] = {1, 3, 5, 2, 3}; s = 5

Ans: a1 = 3, a2 = 4

Explanation: The repeating number is 3, and the missing number is 4.

Example: 2

arr[] = {1, 2, 1}; s = 3

Ans: a1 = 1, a2 = 3

Explanation: The repeating number is 1, and the missing number is 3.

FileName: MissingAndRepeatingElement.java

// import statement
import java. util. Arrays;

public class MissingAndRepeatingElement
{
void findEle(int a[], int s)
{

// finding sum of n natural numbers (n * (n + 1)) / 2
long nsum = (s * (s + 1)) / 2;

// finding sum of square of n natural numbers (n * (n + 1) * (2 * n + 1)) / 6
long nsqrsum = (nsum * ( 2 * s + 1)) / 3;


long sqrsum = 0, sum = 0;

for(int i = 0; i < s; i++)
{
// find sum of elements present in the array
sum = sum + a[i];

// finding sum of square of elements presenet in the array
sqrsum = sqrsum + ((long) a[i] * a[i]);
}

// finding a1^2 - a2^2
long sqrdiff = sqrsum - nsqrsum;

// finding a1 - a2
long diff = sum - nsum;

// finding a1 + a2 using mathematical identity
// a1^2 - a2^2 = (a1 + a2)(a1 - a2)
sum = sqrdiff/diff;

// finding a1 using a1 + a2 and a1 - a2
long a1 = (sum + diff)/2;

// finding y
long a2 = sum - a1;

System.out.println("For array: " + Arrays.toString(a) + "\n");
System.out.println("a1 is: " + a1);
System.out.println("a2 is: " + a2);

return;
}

public static void main(String argvs[])
{
// creating an object of the class MissingAndRepeatingElement
MissingAndRepeatingElement obj = new MissingAndRepeatingElement();

int arr[] = {1, 3, 5, 4, 1};
int size = arr.length;

obj.findEle(arr, size);

int arr1[] = {1, 3, 5, 2, 3};
size = arr1.length;

System.out.println();
obj.findEle(arr1, size);

}
}

Output:

For array: [1, 3, 5, 4, 1]

a1 is: 1
a2 is: 2

For array: [1, 3, 5, 2, 3]

a1 is: 3
a2 is: 4

3) Given a read-only array arr of size s. Find out the number of ways one can divide the array arr into 3 parts such that the sum of each part is equal.

Example: 1

arr[] = {0, 1, -1, 0}; s = 4

Ans: 1

Explanation: There is only one way to split the array into three parts whose sum is equal. {0}, {1, -1}, {0}

Example: 2

arr[] = {2, 2, 4, 0, 4}; s = 5

Ans: 2

Explanation: There are two ways to split the array into three parts whose sum is equal.

{2, 2}, {4, 0}, {4}

{2, 2}, {4}, {0, 4}

FileName: ParititionArray.java

// import statement
import java. util. Arrays;

public class PartitionArray
{
// A method that returns the number of ways
// the array arr can be partitioned into 3 parts
// such that sum of each part is equal
int countWays(int arr[], int size)
{

int pre[] = new int[size + 1];
pre[0] = 0;;
for (int j = 0; j < size; j++) 
{
// Creating a prefix array for retrieving the sum in O(1)
pre[j + 1] = pre[j] + arr[j]; 
}

int ans = 0;
  
// Sum of all the elements of the array must be divisible 
// by 3; otherwise, it is not possible to partition the array
if(pre[size] % 3 == 0) 
{
// partition happen at two points at 1 / 3 and 2 / 3
int u = pre[size] / 3;
int v = 2 * pre[size] / 3;   
// Count for first partition
int count = 0;                  
for (int j = 1; j < size; j++) 
{
if (pre[j] == v)
{
// If the sum is of 2 partitions, then add the count to answer
ans = ans + count; 
}

if (pre[j] == u)
{
 // If sum is of 1 partition then increase the count by 1
count = count + 1; 
}
}
}
return ans;   
}
public static void main(String argvs[])
{
// creating an object of the class PartitionArray
PartitionArray obj = new PartitionArray();

int arr[] = {2, 2, 4, 0, 4};
int size = arr.length;

int ways = obj.countWays(arr, size);


System.out.println("For array: " + Arrays.toString(arr));
System.out.println("The number of ways to it partition is: " + ways + "\n");

int arr1[] = {-1, 1, 0, 0, -1, 1};
size = arr1.length;

ways = obj.countWays(arr1, size);

System.out.println("For array: " + Arrays.toString(arr1));
System.out.println("The number of ways to it partition is: " + ways + "\n");


int arr2[] = {4, 6, 8, 9, -13, 9};
size = arr2.length;

ways = obj.countWays(arr2, size);

System.out.println("For array: " + Arrays.toString(arr2));
System.out.println("The number of ways to it partition is: " + ways);

}
}

Output:

For array: [2, 2, 4, 0, 4]
The number of ways to it partition is: 2

For array: [-1, 1, 0, 0, -1, 1]
The number of ways to it partition is: 3

For array: [4, 6, 8, 9, -13, 9]
The number of ways to it partition is: 0

4) An array arr of N integers X1, X2, X3, ...., Xn is given. You have to return the maximum value of f(a1, a2), where 0 ≤ a1, a2, < N. It is given that f(a1, a2) = |arr[a1] - a[a2]| + |a1 - a2|, where |y| represents the absolute value of y.

Example: 1

arr[] = {1, -1, 3};

Ans: 5

Explanation:

f(0, 0) = f(1, 1) = f(2, 2) = 0

f(0, 1) = f(1, 0) = 3

f(0, 2) = f(2, 0) = 4

f(1, 2) = f(2, 1) = 5

We see that the maximum value is 5. Hence, the answer is 5.

Example: 2

arr[] = {2, -1, -1, 3};

Ans: 6

Explanation:

f(0, 0) = f(1, 1) = f(2, 2) = f(3, 3) = 0

f(0, 1) = f(1, 0) = 4

f(0, 2) = f(2, 0) = 5

f(0, 3) = f(3, 0) = 4

f(1, 2) = f(2, 1) = 1

f(1, 3) = f(3, 1) = 6

f(2, 3) = f(3, 2) = 5

We see that the maximum value is 6. Hence, the answer is 6.

FileName: AbsoluteValue.java

// import statement
import java. util. Arrays;

public class AbsoulteValue
{
public int maxVal(int arr[], int s)
{
int max1 = Integer.MIN_VALUE;
int max2 = Integer.MIN_VALUE;
int min1 = Integer.MAX_VALUE;
int min2 = Integer.MAX_VALUE;

// loop for finding the maximum and minimum value of
// arr[i] + i and arr[i] - i
for(int i  = 0; i < s; i++)
{
max1 = Math.max(max1, arr[i] + i);
min1 = Math.min(min1, arr[i] + i);
min2 = Math.min(min2, arr[i] - i);
max2 = Math.max(max2, arr[i] - i);

}

// finding the maximum between
// max(arr[i] + i) - min(arr[i] + i) &
// max(arr[i] - i) - min(arr[i] - i)
int ans = Math.max(max1 - min1, max2 - min2);
return ans;
}

// main method
public static void main(String argvs[])
{
// creating an object of the class AbsoulteValue
AbsoulteValue obj = new AbsoulteValue();
int arr[] ={1, 3, -1};
int size = arr.length;

int ans = obj.maxVal(arr, size);

System.out.print("The maximum absolute value of the array: " + Arrays.toString(arr));
System.out.println(" is " + ans + "\n");

int arr1[] = {3, 4, 5, 9, 12};

size = arr1.length;

ans = obj.maxVal(arr1, size);

System.out.print("The maximum absolute value of the array: " + Arrays.toString(arr1));
System.out.println(" is " + ans + "\n");

int arr2[] = {13, -4, 5, -12};

size = arr2.length;

ans = obj.maxVal(arr2, size);

System.out.print("The maximum absolute value of the array: " + Arrays.toString(arr2));
System.out.println(" is " + ans + "\n");

int arr3[] = {-1, 2, 9, -7};

size = arr3.length;

ans = obj.maxVal(arr3, size);

System.out.print("The maximum absolute value of the array: " + Arrays.toString(arr3));
System.out.println(" is " + ans + "\n");

}
}

Output:

The maximum absolute value of the array: [1, 3, -1] is 5

The maximum absolute value of the array: [3, 4, 5, 9, 12] is 13

The maximum absolute value of the array: [13, -4, 5, -12] is 28

The maximum absolute value of the array: [-1, 2, 9, -7] is 17

5) Find the next permutation of the number that is formed by the elements of the array arr of size s without changing the order of elements.

Example: 1

arr[] = {3, 1, 2}; s = 3;

Ans: 321

Explanation: The number formed using the array elements is 312. The next permutation of the number 312 is 321.

Example: 2

arr[] = {1, 2, 3};

Ans: 132

Explanation: The number formed using the array elements is 123. The next permutation of the number 123 is 132.

FileName: NextPermutation.java

// import statement
import java.util.Arrays;

public class NextPermutation
{
// reversing the array from the position pos
public void reverse(int array[], int pos)
{
int size = array.length;

for(int i = pos, j = size - 1; i <= j; i++, j--)
{
// swap elements
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}


//  a method that finds next permutation using the array elements
public int[] nextPermutation(int arr[], int s)
{
if(s == 1) 
{
return arr;
}
int i;
for(i = s - 2; i >= 0; i--)
{
if(arr[i] < arr[i + 1])
break;
}
// if the whole array is sorted in the ascending order
// then the next permutation is reverse of the array arr
if(i < 0)
{
// reverse the complete array
reverse(arr, 0);

return arr;
}
int j;
for(j = s - 1; j > i; j--)
{
if(arr[j] > arr[i])
{
break;
}
}

// swap elements
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;

// reverse from position i + 1
reverse(arr, i + 1);

return arr;

}

// generating number from the array elements
int findNo(int arr[], int size)
{
    int ans = 0;
    for(int i = 0; i < size; i++)
    {
        ans = arr[i] + (ans * 10);
    }
    
    return ans;
}

// main method
public static void main(String argvs[])
{
// creating an object of the class NextPermutation
NextPermutation obj = new NextPermutation();

// input array - 1
int arr[] ={1, 2, 3};
int size = arr.length;

int orginialNo = obj.findNo(arr, size);

int ans[] = obj.nextPermutation(arr, size);

int permutedNo = obj.findNo(ans, size);

System.out.println("The next permutation of " + orginialNo + " is " + permutedNo);

// input array - 2
int arr1[] ={1, 4, 3, 2};
size = arr1.length;

orginialNo = obj.findNo(arr1, size);

int ans1[] = obj.nextPermutation(arr1, size);

permutedNo = obj.findNo(ans1, size);

System.out.println("The next permutation of " + orginialNo + " is " + permutedNo);

// input array - 3
int arr2[] ={1, 3, 7, 9, 4};
size = arr2.length;

orginialNo = obj.findNo(arr2, size);

int ans2[] = obj.nextPermutation(arr2, size);

permutedNo = obj.findNo(ans2, size);

System.out.println("The next permutation of " + orginialNo + " is " + permutedNo);

}
}

Output:

The next permutation of 123 is 132
The next permutation of 1432 is 2134
The next permutation of 13794 is 13947

6) There is an array arr, which contains only non-negative numbers. Create the largest number using all of the non-negative numbers of the given array arr.

Example: 1

arr[] = {35, 1, 9};

Ans: 9351

Explanation: 9 is the largest number digit, so it will be put first. After that, the digit 3 is greater than digit 1. Therefore, 35 is put before 1.

Example: 2

arr[] = {17, 22, 83, 7, 5};

Ans: 83752217

Explanation: 8 is the largest digit in the given array. Therefore, 83 is put first. The same treatment is given to other numbers too.

FileName: LargestNoExample.java

// import statement
import java.util.*;

public class LargestNoExample 
{

public String largestNumber(int a[], int size) 
{

String[] arr = new String[size];
for (int i = 0; i < size; i++) 
{
arr[i] = String.valueOf(a[i]);
}


Arrays.sort(arr, new Comparator<String>()
{
public int compare(String a, String b)
{
    // the biggest digit has to be put first
    return (b + a).compareTo(a + b);
}
});


StringBuilder sb = new StringBuilder();
for(String s: arr)
{
sb.append(s);
}

// if 0 is present is at the 
// first index, then it means all the
// number present at the other index are also zero
if(sb.charAt(0) == '0')
{    
//check if all zeroes are there
return String.valueOf(0);
}

return sb.toString();   
}
    
    
// main method
public static void main(String argvs[])
{
    
// creating an object of the class LargestNoExample
LargestNoExample obj = new LargestNoExample();

// input array - 1
int arr[] = {17, 22, 83, 7, 5};
int size = arr.length;

String str = obj.largestNumber(arr, size);

System.out.println("The largest number formed from the array: " + Arrays.toString(arr) + " is " + str);


// input array - 2
int arr1[] = {79, 21, 83, 7, 58};
size = arr1.length;

str = obj.largestNumber(arr1, size);

System.out.println("The largest number formed from the array: " + Arrays.toString(arr1) + " is " + str);


// input array - 2
int arr2[] = {0, 9, 99, 79, 87, 158};
size = arr2.length;

str = obj.largestNumber(arr2, size);

System.out.println("The largest number formed from the array: " + Arrays.toString(arr2) + " is " + str);

}

}

Output:

The largest number formed from the array: [17, 22, 83, 7, 5] is 83752217
The largest number formed from the array: [79, 21, 83, 7, 58] is 837975821
The largest number formed from the array: [0, 9, 99, 79, 87, 158] is 99987791580

7) A 2-dimensional matrix containing m rows and m columns is given. The task is to do the rotation of the matrix by 90 degrees in a clockwise manner.

Example: 1

Example: 2

FileName: RotateMatrix.java

// import statement
import java.util.Arrays;

public class RotateMatrix
{
public void rotate(int al[][]) 
{
transpose(al); 
int rowSize = al.length;
int colSize = al[0].length;
int i = 0;
while(i < colSize)
{
for(int j = 0; j < rowSize; j++)
{
    int temp =  al[j][i];
    al[j][i] = al[j][colSize - 1];
    al[j][colSize - 1] = temp;
}

i = i + 1;
colSize = colSize - 1;
}
}

void transpose(int a[][]) 
{ 
int rowSize = a.length;
int colSize = a[0].length;
for (int row = 0; row < rowSize; row++) 
{
for (int col = row; col < colSize; col++) 
{ 
    int temp = a[row][col];
    a[row][col] = a[col][row];
    a[col][row] = temp;
} 
}
}

public void display(int arr[][])
{
int rowSize = arr.length;
int colSize = arr[0].length;

for(int i = 0; i < rowSize; i++)
{
for(int j = 0; j < colSize; j++)
{
    System.out.print(arr[i][j] + " ");
}

System.out.println();
}
}

    
// main method
public static void main(String argvs[])
{
    
// creating an object of the class RotateMatrix
RotateMatrix obj = new RotateMatrix();

int[][] arr = new int[2][2];

arr[0][0] = 1; arr[0][1] = 3;
arr[1][0] = 2; arr[1][1] = 4;

System.out.println("The array is: ");
obj.display(arr);

obj.rotate(arr);
System.out.println();
System.out.println("After rotating to 90 degrees clockwise the array is: ");
obj.display(arr);

int[][] arr1 = new int[4][4];

arr1[0][0] = 4; arr1[0][1] = 8; arr1[0][2] = 7; arr1[0][3] = 2;
arr1[1][0] = 9; arr1[1][1] = 5; arr1[1][2] = 6; arr1[1][3] = 3;
arr1[2][0] = 0; arr1[2][1] = 8; arr1[2][2] = 1; arr1[2][3] = 6;
arr1[3][0] = 4; arr1[3][1] = 3; arr1[3][2] = 2; arr1[3][3] = 5; 

System.out.println();
System.out.println("The array is: ");
obj.display(arr1);

obj.rotate(arr1);
System.out.println();
System.out.println("After rotating to 90 degrees clockwise the array is: ");
obj.display(arr1);

}

}

Output:

The array is: 
1 3 
2 4 

After rotating to 90 degrees clockwise the array is: 
2 1 
4 3 

The array is: 
4 8 7 2 
9 5 6 3 
0 8 1 6 
4 3 2 5 

After rotating to 90 degrees clockwise the array is: 
4 0 9 4 
3 8 5 8 
2 1 6 7 
5 6 3 2

8) There is an array arr, which contains only non-negative numbers. Find the subarray of the smallest size from the given array arr, which gets sorted; then the whole array gets sorted.

Example: 1

arr[] = {2, 4, 3, 8, 9};

Ans: {1, 2}

Explanation: The subarray starting from index 1 and ending at index 2 is the smallest subarray that gets sorted, then the whole array gets sorted.

Example: 2

arr[] = {12, 34, 45, 67, 78, 88, 99, 102};

Ans: { }

Explanation: The given array is already sorted. Hence, the subarray is empty.

FileName: SmallestSubArray.java

// import statement
import java.util.Arrays;

public class SmallestSubArray 
{
// method that finds the starting and ending 
// indices of the subarray that should be sorted to 
// sort the whole array
public int[] findSubarray(int a[], int size)
{
// for storing the first index of the subarray
int first = -1;

// for storing the second index of the subarray
int second = -1;
// for storing the result
int ans[] = {-1, -1};
for(int i = 0; i < size - 1; i++)
{
if(a[i] > a[i + 1])
{
first = i + 1;
break;
}
}

if(first == -1)
{
// if control reaches here, then the input array is already sorted.
return ans;
}

for(int j = size - 1; j >= 1; j--)
{
if(a[j] < a[j - 1])
{
second = j - 1; 
break;
}
}

int temp = first;
for(int i1 = temp; i1 < size; i1++)
{
if(a[i1] <= a[first])
first = i1;
}
temp = second;
for(int j = temp; j >= 0; j--)
{
if(a[j] >= a[second])
second = j;

}

temp = first;
for(int i = 0; i <= temp; i++)
{
if(a[i]  > a[first])
{
first = i; 
break;
}

}

temp = second;
for(int i = size-1; i >= temp; i--)
{
if(a[i] < a[second])
{
second = i; 
break;

}
}


ans[0] = first;
ans[1] = second;

return ans;
}

// main method
public static void main(String argvs[])
{
    
// creating an object of the class SmallestSubArray
SmallestSubArray obj = new SmallestSubArray();

int[] arr = {2, 4, 3, 8, 9};
int size = arr.length;
System.out.println("The array is: " + Arrays.toString(arr));
int ans[] = obj.findSubarray(arr, size);
if(ans[0] < 0)
{
System.out.println("Minimum subarray is not found as the array is already sorted \n");
}
else
{
System.out.println("Minimum subarray for sorting the array is:");
System.out.print("[");
for(int i = ans[0]; i < ans[1]; i++)
{
System.out.print(arr[i] + ", ");
}
System.out.println(arr[ans[1]] + "] \n");
}


int[] arr1 = {12, 34, 45, 67, 78, 88, 99, 102, 345, 555, 666, 777, 888, 999};
size = arr.length;
System.out.println("The array is: " + Arrays.toString(arr1));
int ans1[] = obj.findSubarray(arr1, size);
if(ans1[0] < 0)
{
System.out.println("Minimum subarray is not found as the array is already sorted \n");
}
else
{
System.out.println("Minimum subarray for sorting the array is:");
System.out.print("[");
for(int i = ans1[0]; i < ans1[1]; i++)
{
System.out.print(arr1[i] + ", ");
}
System.out.println(arr1[ans1[1]] + "] \n");
}


int[] arr2 = {1, 2, 3, 3, 4, 4, 5, 5, 7, 8, 9, 20, 14, 16, 19, 14, 19, 19, 20, 21, 22, 27, 30};
size = arr2.length;
System.out.println("The array is: " + Arrays.toString(arr2));
int ans2[] = obj.findSubarray(arr2, size);
if(ans2[0] < 0)
{
System.out.println("Minimum subarray is not found as the array is already sorted \n");
}
else
{
System.out.println("Minimum subarray for sorting the array is:");
System.out.print("[");
for(int i = ans2[0]; i < ans2[1]; i++)
{
System.out.print(arr2[i] + ", ");
}
System.out.println(arr2[ans2[1]] + "] \n");
}

}
}

Output:

The array is: [2, 4, 3, 8, 9]
Minimum subarray for sorting the array is:
[4, 3] 

The array is: [12, 34, 45, 67, 78, 88, 99, 102, 345, 555, 666, 777, 888, 999]
Minimum subarray is not found as the array is already sorted 

The array is: [1, 2, 3, 3, 4, 4, 5, 5, 7, 8, 9, 20, 14, 16, 19, 14, 19, 19, 20, 21, 22, 27, 30]
Minimum subarray for sorting the array is:
[20, 14, 16, 19, 14, 19, 19]

9) An array arr with size sz, a key k, and the segment size s is given, such that s completely divides sz. Check whether each segment of the array arr of size s has the key k present or not.

Example: 1

arr[] = {5, 3, 2, 4, 3, 9, 11, 3, 12, 67, 45, 3}; sz = 12; k = 3; s = 3;

Ans: Yes, each segment of the array arr of size s contains the key k.

Explanation: sz / s = 12 / 3 = 4. These four segments are:

{5, 3, 2} -----> contains the key 3

{4, 3, 9} -----> contains the key 3

{11, 3, 12} -----> contains the key 3

{67, 45, 3} -----> contains the key 3

Thus, each segment contains the key k, which is 3.

Example: 2

arr[] = {23, 56, 65, 21, 34, 67, 89, 9, 0, 23, 55, 44, 33, 22, 23}; sz = 15; k = 23; s = 5;

Ans: Yes, each segment of the array arr of size s contains the key k.

Explanation: sz / s = 15 / 5 = 3. These three segments are:

{23, 56, 65, 21, 34} -----> contains the key 23

{67, 89, 9, 0, 23} -----> contains the key 23

{55, 44, 33, 22, 23} -----> contains the key 23

Thus, each segment contains the key k, which is 23.

FileName: ArraySegmentKey.java

// A Java code that finds the every
// segment of size s of array arr have
// key K or not

import java.util.*;
public class ArraySegmentKey 
{
public boolean findingKinWindowSize(int size, int[] arr, int K, int s)
{
int i;
boolean b = false;

// Iterate from 0 to size - 1
for (i = 0; i < size; i = i + s) 
{
int j;
// Iterate from 0 to s - 1
for (j = 0; j < s; j++) 
{
if (i + j < size && arr[i + j] == K)
{
break;
}
}
if (j == s)
{
return false;
}
if (i + j >= size)
{
return false;
}
}
if (i >= size)
{
return true;
}
else
{
return b;
}
}

// main method
public static void main(String argvs[])
{
// creating an object of the class ArraySegmentKey
ArraySegmentKey obj = new ArraySegmentKey();

int arr[] = {5, 3, 2, 4, 3, 9, 11, 3, 12, 67, 45, 3};
int k = 3;
int s = 3;
int sz = arr.length;
if (obj.findingKinWindowSize(sz, arr, k, s))
{
System.out.println("For array " + Arrays.toString(arr));
System.out.println("Each segment of size " + s + " contains the key " + k + "\n");
}
else
{
System.out.println("For array " + Arrays.toString(arr));
System.out.println("Each segment of the array of size " + s + " does not contain the key " + k + "\n");
}

int arr1[] = {23, 56, 65, 21, 34, 67, 89, 9, 0, 23, 55, 44, 33, 22, 23};
int k1 = 23;
int s1 = 5;
int sz1 = arr1.length;
if (obj.findingKinWindowSize(sz1, arr1, k1, s1))
{
System.out.println("For array " + Arrays.toString(arr1));
System.out.println("Each segment of size " + s1 + " contains the key " + k1 + "\n");
}
else
{
System.out.println("For array " + Arrays.toString(arr1));
System.out.println("Each segment of the array of size " + s1 + " does not contain the key " + k1 + "\n");
}

int arr2[] = {1, 6, 7, 2, 3, 8, 9};
int k2 = 6;
int s2 = 1;
int sz2 = arr2.length;
if (obj.findingKinWindowSize(sz2, arr2, k2, s2))
{
System.out.println("For array " + Arrays.toString(arr2));
System.out.println("Each segment of size " + s2 + " contains the key " + k2 + "\n");
}
else
{
System.out.println("For array " + Arrays.toString(arr2));
System.out.println("Each segment of the array of size " + s2 + " does not contain the key " + k2 + "\n");
}

}
}

Output:

For array [5, 3, 2, 4, 3, 9, 11, 3, 12, 67, 45, 3]
Each segment of size 3 contains the key 3

For array [23, 56, 65, 21, 34, 67, 89, 9, 0, 23, 55, 44, 33, 22, 23]
Each segment of size 5 contains the key 23

For array [1, 6, 7, 2, 3, 8, 9]
Each segment of the array of size 1 does not contain the key 6

10) Given a string, the task is to search the rank of the given string amongst its lexicographically sorted permutations. The characters of the given string may or may not be repeated. If the characters are repeated, one needs to look at the unique permutations and then determine the rank.

Example: 1

str = "caa"

Ans: The rank of "caa" is 3 among its lexicographically sorted permutations.

Explanation: The string has three characters, 'a', 'a', and 'c', and their lexicographically sorted permutations are:

"aac" ----------> rank - 1

"aca" ----------> rank - 2

"caa" ----------> rank - 3

Hence, the rank is 3.

Example: 2

str = "dcab"

Ans: The rank of "dcab" is 23 among its lexicographically sorted permutations.

Explanation: The string has four characters, 'a', 'b', 'c', 'd', and their lexicographically sorted permutations are:

"abcd" ----------> rank - 1

"abdc" ----------> rank - 2

"acbd" ----------> rank - 3

"acdb" ----------> rank - 4

"adbc" ----------> rank - 5

"adcb" ----------> rank - 6

"bacd" ----------> rank - 7

"badc" ----------> rank - 8

"bcad" ----------> rank - 9

"bcda" ----------> rank - 10

"bdac" ----------> rank - 11

"bdca" ----------> rank - 12

"cabd" ----------> rank - 13

"cadb" ----------> rank - 14

"cbad" ----------> rank - 15

"cbda" ----------> rank - 16

"cdab" ----------> rank - 17

"cdba" ----------> rank - 18

"dabc" ----------> rank - 19

"dacb" ----------> rank - 20

"dbac" ----------> rank - 21

"dbca" ----------> rank - 22

"dcab" ----------> rank - 23

Hence, the rank is 23.

FileName: PermutationRank.java

public class PermutationRank 
{
// a method that finds the rank
public int findRank(String str) 
{
int size = str.length();
// for storing factorials of numbers
long[] fact = new long[size + 1];
fact[0] = 1;

for (int i = 1; i <= size; i++) 
{
fact[i] = (fact[i - 1] * i);
}

// for storing the frequency of character 
int[] c = new int[52];

for (char ch : str.toCharArray()) 
{
c[o(ch)] = c[o(ch)] + 1;
}

long rank = 0;
int count = str.length();

for (char ch : str.toCharArray()) 
{
count = count - 1;
for (int t = 0; t < o(ch); t++) 
{
if (c[t] > 0) 
{
c[t] = c[t] - 1;
long trank = fact[count];

for (int i = 0; i < 52; i++) 
{
if (c[i] > 0) 
{
// a! / b!
// where a! represent the factorial when the charactes are unique and
// where b! is the factorial of repeated characters
trank = (trank / fact[c[i]]);
}
}
rank = (rank + trank);
c[t] = c[t] + 1;
}
}
c[o(ch)] = c[o(ch)] - 1;
}
return new Long((rank + 1)).intValue();
}

private int o(char ch) 
{
if (ch <= 'Z') return ch - 'A';
return ch - 'a' + 26;
}

// main method
public static void main(String argvs[])
{
PermutationRank obj = new PermutationRank();
String str = "caa";
int rank = obj.findRank(str);
str = "'caa'";
System.out.print("The rank of the string " + str + " is ");
System.out.println(rank + " among its lexicographically sorted permutations. \n");


str = "dcab";
rank = obj.findRank(str);
str = "'dcab'";
System.out.print("The rank of the string " + str + " is ");
System.out.println(rank + " among its lexicographically sorted permutations. \n");


str = "haaxxy";
rank = obj.findRank(str);
str = "'haaxxy'";
System.out.print("The rank of the string " + str + " is ");
System.out.println(rank + " among its lexicographically sorted permutations. \n");

str = "mttlks";
rank = obj.findRank(str);
str = "'mttlks'";
System.out.print("The rank of the string " + str + " is ");
System.out.println(rank + " among its lexicographically sorted permutations. \n");
}

}

Output:

The rank of the string 'caa' is 3 among its lexicographically sorted permutations. 

The rank of the string 'dcab' is 23 among its lexicographically sorted permutations. 

The rank of the string 'haaxxy' is 61 among its lexicographically sorted permutations. 

The rank of the string 'mttlks' is 177 among its lexicographically sorted permutations.

11) Given two sorted arrays, arr and arr1. Their size may not be or maybe equal. Find the median of these given arrays. Note that merging of the sorted arrays is not allowed.

Example: 1

arr = {-11, -10, -9, -2, 5, 17}

arr1 = {-4, 4, 7, 13, 16, 17, 19}

Ans: The median of these sorted arrays is at the index.

Explanation: When these sorted arrays are merged, we get the following.

mergedArray = {-11, -10, -9, -4, -2, 4, 5, 7, 13, 16, 17, 17, 19};

The size of the mergedArray is 13, which is odd. Hence, there is only one middle element sitting at the index 13 / 2 = 6. At the 6^th index, we get 5. Hence, 5 is the median of these sorted arrays.

Note: We are merging it here only for the explanation purpose. In the code, we will not merge the arrays.

Example: 2

arr = {5, 7, 9, 11, 13, 16, 19, 22}

arr1 = {-4, 4, 7, 8, 10, 11, 12, 14}

Ans: The median of these sorted arrays is 10.

Explanation: When these sorted arrays are merged, we get the following.

mergedArray = {-4, 4, 5, 7, 7, 8, 9, 10, 11, 11, 12, 13, 14, 16, 19, 22};

The size of the mergedArray is 16, which is even. Hence, there are two middle elements which are sitting at 16 / 2 = 8^th and 16 / 2 - 1 = 7^th indices. Thus, the median is (10 + 11) / 2 = 10.5.

FileName: FindMedian.java

// import statement
import java.util.Arrays;

public class FindMedian 
{

// A utility method to get the median of two integers
private float MOI2(int x, int y) 
{
return (float) ((x + y) / 2.0);
}

// A utility method to get the median of three integers
private float MOI3(int x, int y, int z) 
{
return x + y + z - Math.max(x, Math.max(y, z)) - Math.min(x, Math.min(y, z));
}

// A utility method to get the median of four integers
private float MOI4(int w, int x, int y, int z) 
{
int max = Math.max(w, Math.max(x, Math.max(y, z)));
int min = Math.min(w, Math.min(x, Math.min(y, z)));
return (float) ((w + x + y + z - max - min) / 2.0);
}

// a utility method to get the median of a single array
private float medSingle(int arr1[], int s) 
{
if (s == 0)
{
return -1;
}
if (s % 2 == 0)
{
return (float) ((double) (arr1[s / 2] + arr1[s / 2 - 1]) / 2);

}

return arr1[s / 2];
}

// The method assumes that s2 is less than or equal to s1
// the method returns -1 if both the arrays are empty
private float findMedUtil(int arr1[], int s2, int arr2[], int s1) 
{

// the median only lies in the second array if the
// first array is empty
if (s2 == 0)
return medSingle(arr1, s1);

// only one element is present in the smaller array
if (s2 == 1) 
{

// Case 1: only one element is present in the larger array,
// simply call MO2()
if (s1 == 1)
return MOI2(arr1[0], arr2[0]);

// Case 2: consider the middle 3 elements of larger array and
// the only element of smaller array, if the larger array 
// has odd number of elements. 
if (s1 % 2 == 1)
{
return MOI2(arr2[s1 / 2], (int) MOI3(arr1[0], arr2[s1 / 2 - 1], arr2[s1 / 2 + 1]));
}

// Case 3: The following will be the three elements 
// if the larger array has even number of elements
// ... The middle two elements of the larger array
// ... The only one element of the smaller array
return MOI3(arr2[s1 / 2], arr2[s1 / 2 - 1], arr1[0]);
}

// two elements is present in the smaller array
else if (s2 == 2) 
{

// Case 4: Invoke MOI4() when the larger array also has two elements
if (s1 == 2)
{
return MOI4(arr1[0], arr1[1], arr2[0], arr2[1]);
}

// Case 5: when number of elements are present in the larger array are not multiple of 2
// then the median will be one of the following 3 elements
// 1. In the larger array, the element at the middle index
// 2. Maximum of the first element of the smaller array 
//    and element just before the middle of the larger array
// 3. Minimum of the second element of the smaller array and 
//    element just after the middle of the larger array
if (s1 % 2 == 1)
{
return MOI3(arr2[s1 / 2], Math.max(arr1[0], arr2[s1 / 2 - 1]), Math.min(arr1[1], arr2[s1 / 2 + 1]));
}

// Case 6: when number of elements are present in the larger array are multiples of 2
// Then, the median eleement will be one the following four elements
// 1 & 2) two middle elements of the larger array
// 3) In the smaller array, the maximum of the first element and 
//    the element that comes just before the first middle element present in the larger array
// 4. In the smaller array, the minimum of the second element and 
//    element just after the second middle in the larger array
return MOI4(arr2[s1 / 2], arr2[s1 / 2 - 1], Math.max(arr1[0], arr2[s1 / 2 - 2]), Math.min(arr1[1], arr2[s1 / 2 + 1]));
}

int indxa = (s2 - 1) / 2;
int indxb = (s1 - 1) / 2;

/*
* if a[indxa] <= b[indxb], then median
must be present in a[indxa....] and B[....indxb]
*/
if (arr1[indxa] <= arr2[indxb])
{
return findMedUtil(Arrays.copyOfRange(arr1, indxa, arr1.length), s2 / 2 + 1, arr2, s1 - indxa);
}

/*
* if arr1[indxa] > arr2[indxb], then median
must be present in arr1[...indxa] and arr2[indxb....]
*/
return findMedUtil(arr1, s2 / 2 + 1, Arrays.copyOfRange(arr2, indxb, arr2.length), s1 - indxa);
}

// A wrapper method written around the findMedianUtil(). The method
// ensures that the smaller array is passed as first argument
// to findMedUtil
public float findMedn(int arr1[], int s2, int arr2[], int s1)
{
if (s2 > s1)
{
return findMedUtil(arr2, s1, arr1, s2);
}

return findMedUtil(arr1, s2, arr2, s1);
}

// main method
public static void main(String argvs[])
{
// instantiating the class FindMedian
FindMedian obj = new FindMedian();

int arr1[] = {-11, -10, -9, -2, 5, 17};
int arr2[] = {-4, 4, 7, 13, 16, 17, 19};

int s2 = arr1.length;
int s1 = arr2.length;  

float f = obj.findMedn(arr1, s2, arr2, s1);

System.out.println("The median element is: " + f + "\n");


int arr3[] = {5, 7, 9, 11, 13, 16, 19, 22};
int arr4[] = {-4, 4, 7, 8, 10, 11, 12, 14};
s2 = arr3.length;
s1 = arr4.length;
f = obj.findMedn(arr3, s2, arr4, s1);

System.out.println("The median element is: " + f);
}
}

Output:

The median element is: 5.0

The median element is: 10.5

12) Given an array arr whose size is s. Also, an integer tar is given. The array arr is rotated using an element of the array as pivot {1, 2, 3, 4, 5} might become {4, 5, 1, 2, 3}. Find whether the integer tar is present in the array arr or not. Note that the array arr is sorted in non-decreasing order before the rotation.

Example: 1

arr = {7, 8, 9, 10, 0, 3, 4, 5, 6}; s = 9; tar = 3;

Ans: 5.

Explanation: the number 3 is present at the index 5.

Example: 2

arr = {4, 5, 1, 2, 3}; s = 5; tar = 6;

Ans: -1

Explanation: the number 6 is not present in the array.

FileName: FindElement.java

public class FindElement
{

// when the array is rotated, we get two sorted arrays.
// for example {4, 5, 0, 1, 2, 3} has two sorted arrays
// {4, 5} and {0, 1, 2, 3}. In these two sorted arrays, one 
// can apply the binary search to find the index of the target element.
// Therefore, our first task is to find the boundary which divides 
// the given array into two subarrays which are sorted.
// Then, we will apply the binary search on these two subarrays to 
// look for the target element.

// a method that finds the element ele in the array a of length size
public int findIndex(int a[], int size, int ele)
{
int first = a[0];
int last = a[size - 1];
int mid;
int min = 0;
int max = size - 1;

// loop for finding the boundary
while(max - min != 1)
{
mid= (min + max) / 2;
if(a[mid] >= first)
{
min = mid;
}
else
{
max = mid;
}
}

// boundary found
// one subarray is 0 to min
// and another subarray is min + 1 to size - 1
int min1 = 0;
int min2 = min;

// searching in the first subarray, which is sorted, using the binary search.
while(min1 <= min2)
{
mid = (min1 + min2)/2;
if(a[mid] == ele)
{
return mid;
}
else if(a[mid] > ele)
{
min2 = mid - 1;
}
else
{
min1 = mid + 1;
}
}

min = min + 1;
max= size - 1;

// searching in the second subarray, which is also sorted, using the binary search.
while(min <= max)
{
mid = (min + max) / 2;
if(a[mid] == ele)
{
return mid;
}
else if(a[mid] > ele)
{
max = mid - 1;
}
else
{
min = mid + 1;
}
}

// target element not found!!
return -1;
}

// main method
public static void main(String argvs[])
{
// instantiating the class FindElement
FindElement obj = new FindElement();

// input array 
int arr[] = {7, 8, 9, 10, 0, 3, 4, 5, 6};
int s = arr.length;
int tar = 3; // number to be searched 

int index = obj.findIndex(arr, s, tar);

if(index >= 0)
{
System.out.println("The target element " + tar + " is found at the index " + index + "\n");
}
else
{
System.out.println("The target element is not found! \n");   
}


// input array 
int arr1[] = {34, 56, 67, 12, 13, 14, 15, 26, 28};
s = arr1.length;
tar = 19; // number to be searched 

index = obj.findIndex(arr1, s, tar);

if(index >= 0)
{
System.out.println("The target element " + tar + " is found at the index " + index + "\n");
}
else
{
System.out.println("The target element is not found!");   
}

}

}

Output:

The target element 3 is found at the index 5

The target element is not found!

Note: The linear search will also do the job here. However, its time complexity would be more as compared to the binary search.

13) Given an array arr whose size is s. The array arr is sorted in non-decreasing order. Also, an integer tar is given. Find whether the integer tar is present in the array arr or not. If present, find the starting and ending indices of the integer tar.

Example: 1

arr = {1, 2, 3, 4, 5, 5, 5, 5, 6, 7, 8, 9, 10}; s = 13; tar = 5;

Ans: starting index: 4, ending index: 7

Explanation: Between the indices 4 to 7, the number 5 is present.

Example: 2

arr = {8, 10, 12, 56, 67, 70, 70, 70, 70, 75, 77, 78, 90, 93, 97}; s = 15; tar = 19;

Ans: The target number 19 is not present in the given array

FileName: FindRange.java

// import statement
import java.util.Arrays;

public class FindRange
{
// a method that finds the range of the element target
// in the array a. if the element is not found an array {-1, -1}
// is returned. If the element is found, then the starting 
// and ending index of the element is returned.
public int[] findIndex(int a[], int size, int target)
{
int first = 0;
int last = size - 1;
int ans[] = {-1, -1}; // for storing the indices

// loop for finding the starting index
while(first < last)
{
int mid = (first + last) / 2;
if(a[mid] < target)
{
first = mid + 1;
}
else
{
last = mid;
}
}

// target element is  not found!
// hence {-1, -1} is returned
if(a[first] != target)
{
return ans;
}

// target element is found!
// update the ans array
ans[0] = first;
last = size - 1;

// loop for looking after the ending index
while(first < last)
{   
int mid = (first + ((last - first) / 2)) + 1;
if(a[mid] > target)
{
last = mid - 1;
}
else
{
first = mid;
}

}

ans[1] = last;
return ans;
}

// main method
public static void main(String argvs[])
{
// instantiating the class FindRange
FindRange obj = new FindRange();

// input array 
int arr[] = {1, 2, 3, 4, 5, 5, 5, 5, 6, 7, 8, 9, 10};
int s = arr.length;
int tar = 5; // number to be searched 

int index[] = obj.findIndex(arr, s, tar);

if(index[0] >= 0)
{
System.out.println("Range of target element " + tar + " is: " + Arrays.toString(index) + "\n");
}
else
{
System.out.println("The target element is not found! \n");   
}


// input array 
int arr1[] = {8, 10, 12, 56, 67, 70, 70, 70, 70, 75, 77, 78, 90, 93, 97};
s = arr.length;
tar = 19; // number to be searched 

int index1[] = obj.findIndex(arr1, s, tar);

if(index1[0] >= 0)
{
System.out.println("Range of target element " + tar + " is: " + Arrays.toString(index1) + "\n");
}
else
{
System.out.println("The target element is not found! \n");   
}


}
}

Output:

Range of target element 5 is: [4, 7]

The target element is not found!

14) A string str is given. Find the minimum of characters added to the string str to make it a palindrome string. The characters must be added at the beginning of the string.

Example: 1

str = "ABC";

Ans: 2

Explanation: Inserting "B" at the beginning, we get B + ABC ---> BABC.

Inserting "C" at the beginning, we get C + BABC ---> CBABC. Thus, there are 2 insert operations. Hence, the answer is 2.

Example: 2

str = "ABEBAAAA";

Ans: 3

Explanation: Inserting "A" at the beginning, we get A + ABEBAAAA ---> AABEBAAAA.

Inserting "A" at the beginning, we get A + AABEBAAAA ---> AAABEBAAAA.

Inserting "A" at the beginning, we get A + AAABEBAAAA ---> AAAABEBAAAA.

Thus, there are 3 insert operations. Hence, the answer is 3.

FileName: MakePalindrome.java

public class MakePalindrome
{
public int minNoOfChars(String A) 
{
int n = A.length();
int ans = n;
while(n > 1 && !isPalindrome(A, n)) 
{
n = n - 1;
}
return ans - n;
}

public boolean isPalindrome(String A, int len) 
{
int i = 0, j = len - 1;
while(i <= j && (A.charAt(i) == A.charAt(j))) 
{
i = i + 1;
j = j - 1;
}
if(i > j) 
{
return true;
}
return false;
}

// main method
public static void main(String argvs[])
{
// instantiating the class MakePalindrome
MakePalindrome obj = new MakePalindrome();

String str= "ABC";

int noOfChars = obj.minNoOfChars(str);
str = "'ABC'";

System.out.println(noOfChars + " insert operations are required to make " + str + " a palindrome string." + "\n");

str= "ABEBAAAA";

noOfChars = obj.minNoOfChars(str);
str = "'ABEBAAAA'";

System.out.println(noOfChars + " insert operations are required to make " + str + " a palindrome string." + "\n");

}
}

Output:

2 insert operations are required to make 'ABC' a palindrome string.

3 insert operations are required to make 'ABEBAAAA' a palindrome string.

15) An array of strings and a number n is given. Format the strings present in the array in such a way that each line contains n characters. Insert the strings using the greedy approach, which means insert as many words or characters as one can in a line. Use ' ' character for the padding purpose so that each line has n characters. The extra spaces should be evenly distributed. If the number of spaces does not divide the strings evenly, then the left slot should have more spaces as compared to the right ones. For the last line, the text should be left-justified, i.e., extra spaces should be more on the right side.

Example:

Words = {"It", "is", "the", "example", "of", "sorting", "technique"}

N = 16

Ans: the formatted lines are:

[
"It     is    the"
"example       of"
"sorting         "
"technique       "
]

FileName: TextJustified.java

// import statement
import java.util.*;

public class TextJustified 
{
public ArrayList<String> fullJustify(ArrayList<String> words, int maxWidth) 
{
ArrayList<String> result = new ArrayList<String>();

if(words == null || words.size() == 0)
{
return result;
}


int count = 0;
int last = 0;
ArrayList<String> list = new ArrayList<String>();
for(int i = 0; i < words.size(); i++)
{
count = count + words.get(i).length();

if(count + i - last > maxWidth)
{
int wordsLen = count-words.get(i).length();
int spaceLen = maxWidth - wordsLen;
int eachLen = 1;
int extraLen = 0;

if(i - last - 1 > 0)
{
eachLen = spaceLen / (i - last - 1);
extraLen = spaceLen % (i - last - 1);
}

StringBuilder sb = new StringBuilder();

for(int k = last; k < i - 1; k++)
{
sb.append(words.get(k));

int ce = 0;
while(ce < eachLen)
{
sb.append(" ");
ce = ce + 1;
}

if(extraLen > 0)
{
sb.append(" ");
extraLen = extraLen - 1;
}
}

sb.append(words.get(i - 1)); // the last words of the line

// only single word is possible in this line, required to fill the left with the spaces
while(sb.length() < maxWidth)
{
sb.append(" ");
}

result.add(sb.toString());

last = i;
count=words.get(i).length();
}
}

int lastLen = 0;
StringBuilder sb = new StringBuilder();

for(int i = last; i < words.size() - 1; i++)
{
count = count + words.get(i).length();
sb.append(words.get(i) + " ");
}

sb.append(words.get(words.size() - 1));
int d = 0;
while(sb.length() < maxWidth)
{
sb.append(" ");
}
result.add(sb.toString());

return result;
}
public static void main(String argvs[])
{

// instantiating the class TextJustified
TextJustified obj = new TextJustified();

ArrayList<String> al = new ArrayList<String>
(
Arrays.asList("It", "is", "the", "example", "of", "sorting", "technique")
);
int n = 16;
al = obj.fullJustify(al, n);

for(String str: al)
{
String s = "'";
System.out.println(s + str + s);
}

}
}

Output:

'It     is    the'
'example       of'
'sorting         '
'technique       '

16) An integer array arr is given such that every number is repeated thrice, barring one, which is repeated only once. Return the number that is repeated only once.

Example:

arr[] ={2, 2, 2, 4, 6, 6, 6, 5, 4, 9, 9, 9, 0, 0, 4, 0}

Ans: 5

Explanation: Number 5 is only repeated once.

FileName: UniqueNumber.java

// import statement
import java.util.Arrays;

public class UniqueNumber
{

// a method that finds the number that 
// is repeated only once
public int findNo(int arr[], int size)
{

int singleRepeat = 0;
int doubleRepeat = 0;
int commonMask;
 
for( int j = 0; j < size; j++)
{

// bits that are coming twice
doubleRepeat  = doubleRepeat | (singleRepeat & arr[j]);

// bits that are coming once
singleRepeat  = singleRepeat ^ arr[j];

// bits that common in singleReapt and doubleRepeat
// only possible in those number which are getting
// repeat thrice
commonMask = (singleRepeat & doubleRepeat);

// eliminating the common bits
singleRepeat &= ~commonMask;

doubleRepeat &= ~commonMask;

}

return singleRepeat;


}

// main method
public static void main(String argvs[])
{
// instantiating the class UniqueNumber
UniqueNumber obj = new UniqueNumber();

// input array 
int arr[] = {2, 2, 2, 4, 6, 6, 6, 5, 4, 9, 9, 9, 0, 0, 4, 0};
int s = arr.length;
int uniqueNo = obj.findNo(arr, s);
System.out.println("Array is: " + Arrays.toString(arr));
System.out.println("The unique number is: " + uniqueNo + "\n");

int arr1[] = {6, 6, 6, 1, 1, 1, 4, 4, 4, 12, 0, 0, 0};
s = arr1.length;
uniqueNo = obj.findNo(arr1, s);
System.out.println("Array is: " + Arrays.toString(arr1));
System.out.println("The unique number is: " + uniqueNo + "\n");

}
}

Output:

Array is: [2, 2, 2, 4, 6, 6, 6, 5, 4, 9, 9, 9, 0, 0, 4, 0]
The unique number is: 5

Array is: [6, 6, 6, 1, 1, 1, 4, 4, 4, 12, 0, 0, 0]
The unique number is: 12

17) An integer array arr is given. Rearrange array arr such that arr[i] = arr[arr[i]]. The space complexity must be O(1).

Example:

arr[] = {2, 1, 0}

Ans: {0, 1, 2};

Explanation: arr[0] = 2 => arr[arr[0]] becomes arr[2] = 0;

arr[1] = 1 => arr[arr[1]] = arr[1] = 1

arr[2] = 0 => arr[arr[2]] = arr[0] = 2

Thus, the updated array is {0, 1, 2}

FileName: RearrangeArray.java

// import statement
import java.util.Arrays;

public class RearrangeArray
{

// method for rearranging the elements
public int[] rearrange(int a[], int size)
{
// Increase every Array element Arr[i] by (Arr[Arr[i]] % size) * size
for (int i = 0; i < size; i++)
{
a[i] = ((a[a[i]] % size) * size) + a[i];
}

// Divide every element by size.
for (int i = 0; i < size; i++)
{
a[i] = a[i] / size;
}
return a;
}

// main method
public static void main(String argvs[])
{
RearrangeArray obj = new RearrangeArray();

int a[] = {2, 1, 0};
int size = a.length;
System.out.println("Array before rearranging is: " + Arrays.toString(a));
int res[] = obj.rearrange(a, size);

System.out.println("Array after rearranging is: " + Arrays.toString(res) + "\n");

int arr[] = {2, 4, 3, 1, 0};
size = arr.length;
System.out.println("Array before rearranging is: " + Arrays.toString(arr));
int res1[] = obj.rearrange(arr, size);

System.out.println("Array after rearranging is: " + Arrays.toString(res1));

}
}

Output:

Array before rearranging is: [2, 1, 0]
Array after rearranging is: [0, 1, 2]

Array before rearranging is: [2, 4, 3, 1, 0]
Array after rearranging is: [3, 0, 1, 4, 2]

Note: if the O(1) space complexity condition is removed, then the problem is straightforward. One can create an array of the same size as of input array and can copy the values of a[a[i]] to the recently created array. The O(1) space complexity makes the problem tricky.

18) A positive number n is given. Find the number of trailing zeros that are present in the binary representation of the number.

Example: 1

n = 20

Ans: 2

Explanation: The binary representation of 20 is 10100. The total number of trailing zeros present in 10100 is 2. Hence, the answer is 2.

Example: 2

n = 9

Ans: 0

Explanation: The binary representation of 9 is 1001. The total number of trailing zeros present in 1001 is 0. Hence, the answer is 0.

FileName: TrailingZeros.java

public class TrailingZeros
{
public int countZeros(int n)
{
// array for storing the bits of the number
int arr[] = new int[n];
int index = 0;

// loop for converting the number into its binary representation
while(n != 0)
{
    int bit = n % 2;
    arr[index] = bit;
    index = index + 1;
    n = n / 2;
}

// for counting trailing zeros
int count = 0;

int size = arr.length;
for(int i = 0; i < size; i++)
{
    if(arr[i] == 0)
    {
        count = count + 1;
    }
    else
    {
        break;
    }
}

return count;

}

// main method
public static void main(String argvs[])
{
TrailingZeros obj = new TrailingZeros();

int n = 20;

int countZeros = obj.countZeros(n);

System.out.println("For number " + n + ", there are " + countZeros + " trailing zeros.");

n = 64;

countZeros = obj.countZeros(n);

System.out.println("For number " + n + ", there are " + countZeros + " trailing zeros.");


n = 3;

countZeros = obj.countZeros(n);

System.out.println("For number " + n + ", there are " + countZeros + " trailing zeros.");

}
}

Output:

For number 20, there are 2 trailing zeros.
For number 64, there are 6 trailing zeros.
For number 3, there are 0 trailing zeros.

19) A number n is given. Find the n^th number whose binary representation is a palindrome.

Example: 1

n = 1

Ans: 1

Explanation: The binary representation of 1 is 1, and 1 is a palindrome. 1 is also the 1^st number.

Example: 2

n = 3

Ans: 5

Explanation: The 3^rd number whose binary representation is a palindrome is 5. Its binary representation is 101.

Example: 3

n = 9

Ans: 27

Explanation: The 9^th number whose binary representation is a palindrome is 27. Its binary representation is 11011.

FileName: PalindromeNumbers.java

// import statement
import java.util.*;

public class PalindromeNumbers 
{
// converting the binary string into an integer
public static int changeStringToInt(String str)
{
int a = 0;

// loop for converting the binary string into integer
for (int j = 0; j < str.length(); j++) 
{
if (str.charAt(j) == '1')
{
a += 1 << j;
}
}
return a;
}

// a method for finding the nth number
// whose binary representation is a palindrome
public static int findNthNumber(int no)
{
// stores the binary palindrome string
Queue<String> que = new LinkedList<>();

// base case
if (no == 1)
return 1;
no = no - 1;

// adding the second palindrome string
que.add("11");

while (no-- > 0) 
{

// removing the current binary palindrome string 
// from the queue
String current = que.remove();

if (no == 0)
{
return changeStringToInt(current);
}

int l = current.length();

// if the length is even, then we have to choices
// for example 11 -> 101 or 111
if (l % 2 == 0) 
{
que.add(current.substring(0, l / 2) + "0" + current.substring(l / 2));
que.add(current.substring(0, l / 2) + "1" + current.substring(l / 2));
}

// if the length is odd, then we have only one choice
// for example 1 -> 111
else 
{
char midCh = current.charAt(l / 2);
que.add(current.substring(0, l / 2) + midCh
+ current.substring(l / 2));
}
}
return -1;
}

// main method
public static void main(String[] argvs)
{
int n = 7;
int no = findNthNumber(n);
System.out.println("The " + n + "th number whose binary representation is palindrome is: " + no);

n = 13;
no = findNthNumber(n);
System.out.println("The " + n + "th number whose binary representation is palindrome is: " + no);

}
}

Output:

The 7th number whose binary representation is palindrome is: 17
The 13th number whose binary representation is palindrome is: 51

20) An array arr of integers is given. Also, a sliding window of size w is moving from the left side to the right side of the array. Thus, at a time, one can only watch w numbers. The task is to find the maximum for each window. Observe the following examples.

Example:

arr[] = {1, 4, -1, -4, 6, 4, 7, 8}; w = 3;

Ans: {4, 4, 6, 6, 7, 8}

Explanation:

{[1, 4, -1,] -4, 6, 4, 7, 8} -> max(1, 4, -1) = 4

{1, [4, -1, -4,] 6, 4, 7, 8} -> max(4, -1, -4) = 4

{1, 4, [-1, -4, 6,] 4, 7, 8} -> max(-1, -4, 6) = 6

{1, 4, -1, [-4, 6, 4,] 7, 8} -> max(-4, 6, 4) = 6

{1, 4, -1, -4, [6, 4, 7,] 8} -> max(6, 4, 7) = 7

{1, 4, -1, -4, 6, [4, 7, 8]} -> max(4, 7, 8) = 8

FileName: SlidingWindowMax.java

// import statement
import java.util.*;

public class SlidingWindowMax 
{
// Uses a doubled-ended queue. When going through the array, we only care about the
// largest elements we receive. Any smaller element that came before the current 
// one is no longer required. Essentially our queue must always be in descending order.
public static ArrayList<Integer> slidingMaximum(List<Integer> A, int B) 
{
Deque<Integer> window = new LinkedList<Integer>();
ArrayList<Integer> result = new ArrayList<Integer>();
for (int i = 0; i < A.size(); i++) 
{
int val = A.get(i);
// Remove all elements smaller than the current one from the queue
while (!window.isEmpty() && val >= A.get(window.getLast())) 
{
window.removeLast();
}
// Add the current element's index to the queue. It is important that we
// store the indices rather than the values.
window.add(i);
// The first element of the queue is always the largest. If the index of 
// this number is smaller than the window's stating index, then we remove it
if (window.getFirst() < (i + 1) - B) 
{
window.removeFirst();
}
// Ignores the first few interations
if (i >= B - 1)
{
result.add(A.get(window.getFirst()));
}
}
return result;
}
    
    
// main method
public static void main(String argvs[])
{

ArrayList<Integer> arr = new ArrayList<Integer>
(
Arrays.asList(1, 4, -1, -4, 6, 4, 7, 8)
);

int b = 3;

System.out.println("The array is: " + arr + "\n");

arr = slidingMaximum(arr, b);

System.out.println("The maximum values are: " + arr);


}

}

Output:

The array is: [1, 4, -1, -4, 6, 4, 7, 8]

The maximum values are: [4, 4, 6, 6, 7, 8]

21) An arithmetic expression is given in Reverse Polish Notation. Evaluate the given expression.

Example:

A = ["4", "3", "+", "5", "*"]

Ans: 35

Explanation:

* -> () * ()

5: -> () * (5)

+: (() + ()) * (5)

3: (() + (3)) * (5)

4: ((4) + (3)) * (5)

= (7) * (5) = 35

FileName: EvaluateExpression.java

// import statement
import java.util.*;

public class EvaluateExpression 
{
public static int evaluateExp(ArrayList<String> al) 
{
Stack<Integer> stk = new Stack<>();

for(String st : al) 
{
if(st.equals("+") || st.equals("-") || st.equals("*") || st.equals("/")) 
{
// fetching first two numeric values from the right
// of the array list
int n1 = stk.pop();
int n2 = stk.pop();

// switch case for handling the operation
switch(st) 
{
case "+" : 
int s = n1 + n2;

// after performing the operation add the value to the stack
stk.push(s);
break;
case "-" : 
int d = n2 - n1;
stk.push(d);
break;
case "*" : 
int m = n1 * n2;
stk.push(m);
break;
case "/" : 
int div = n2 / n1;
stk.push(div);
}
}
else 
{
stk.push(Integer.parseInt(st));
}
}

return stk.pop();
}
// main method
public static void main(String argvs[])
{

ArrayList<String> exp = new ArrayList<String>
(
Arrays.asList("4", "3", "+", "5", "*")
);



System.out.println("The expression is: " + exp + "\n");

int ans = evaluateExp(exp);

System.out.println("The value of the expression is: " + ans + "\n");

exp = new ArrayList<String>
(
Arrays.asList("4", "13", "5", "/", "+")
);



System.out.println("The expression is: " + exp + "\n");

ans = evaluateExp(exp);

System.out.println("The value of the expression is: " + ans);


}

}

Output:

The expression is: [4, 3, +, 5, *]

The value of the expression is: 35

The expression is: [4, 13, 5, /, +]

The value of the expression is: 6

22) A number n is given, which represents the total number of bits present in the code. The gray code always starts from 0. Display the sequence of the gray code.

Example:

N = 3;

Ans: {0, 1, 3, 2, 6, 7, 5, 4}

0 0 0 ---> 0

0 0 1 ---> 1

0 1 1 ---> 3

0 1 0 ---> 2

1 1 0 ---> 6

1 1 1 ---> 7

1 0 1 ---> 5

1 0 0 ---> 4

FileName: GrayCode.java

// import statement
import java.util.*;

public class GrayCode 
{
    public ArrayList<Integer> findSeq(int a) 
    {
        ArrayList<Integer> res = new ArrayList<Integer>();
        if(a == 0)
        {
            return res;
        }
        
        // first two gray sequence are always 0 and 1
        res.add(0);
        res.add(1);
        
        if(a== 1)
        {
            return res;
        }
        while(a > 1)
        {
            int s = res.size();
            for(int i = s - 1; i >= 0; i--)
            {
                res.add(s + res.get(i));
            }
            a = a - 1;
        }
        
        return res;
    }
    
// main method
public static void main(String argvs[])
{

int n = 3;
GrayCode obj = new GrayCode();

ArrayList<Integer> al = obj.findSeq(n);

System.out.println("For n = " + n + ", the gray code sequence is: " + al + "\n");

n = 4;
al = obj.findSeq(n);

System.out.println("For n = " + n + ", the gray code sequence is: " + al + "\n");

n = 5;
al = obj.findSeq(n);

System.out.println("For n = " + n + ", the gray code sequence is: " + al + "\n");

}

}

Output:

For n = 3, the gray code sequence is: [0, 1, 3, 2, 6, 7, 5, 4]

For n = 4, the gray code sequence is: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8]

For n = 5, the gray code sequence is: [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8, 24, 25, 27, 26, 30, 31, 29, 28, 20, 21, 23, 22, 18, 19, 17, 16]

23) An array arr containing n integers is given. Find all the unique triplets (x, y, and z) such that x + y + z = 0. Note that ordering of triplets does not matter, i.e., y + z + x or y + x + z is the same as x + y + z.

Example:

arr = {-2, 0, 2, 4, -2, -4};

Ans: There are three unique triplets. {-2, 0, 2}, {-2, -2, 4}, {-4, 0, 4}

FileName: FindTriplets.java

// import statement
import java.util.*;

public class FindTriplet 
{
// a method that finds the unqiue triplets whose sum is zero
public ArrayList<ArrayList<Integer>> threeSumZero(ArrayList<Integer> A) 
{
int B = 0;

// for storing the unique triplets
ArrayList<ArrayList<Integer>> total = new ArrayList();


// sorting the list
Collections.sort(A);
int i = 0;

// loop that uses three pointer approach
while(i < A.size())
{
int j = i + 1, k = A.size() - 1;

while(j < k) 
{
long sum = (long)A.get(i) + (long)A.get(j) + (long)A.get(k);

if(sum == B)
{
ArrayList<Integer> ans = new ArrayList();
ans.add(A.get(i));
ans.add(A.get(j));
ans.add(A.get(k));

// checks whether the found triplet is unique or not
// if unique, then add it; otherwise, discard it.
if(!total.contains(ans))
{
total.add(ans);
}
}
if(sum > B) 
{
k = k - 1;
}

else 
{
j = j + 1;
}
}

i = i + 1;
}
return total;
}
    
// main method
public static void main(String argvs[])
{

// creating an object of the class FindTriplet 
FindTriplet obj = new FindTriplet();
ArrayList<Integer> al = new ArrayList<Integer>
(
Arrays.asList(-2, 0, 2, 4, -2, -4)
);


ArrayList<ArrayList<Integer>> triplets = obj.threeSumZero(al);

System.out.println("For the list: " + al);
System.out.println("Triplets are: " + triplets + "\n");


al = new ArrayList<Integer>
(
Arrays.asList(1, -4, 0, 0, 5, -5, 1, 0, -2, 4, -4, 1, -1, -4, 3, 4, -1, -1, -3)
);

triplets = obj.threeSumZero(al);

System.out.println("For the list: " + al);
System.out.println("Triplets are: " + triplets + "\n");

}

}

Output:

For the list: [-4, -2, -2, 0, 2, 4]
Triplets are: [[-4, 0, 4], [-2, -2, 4], [-2, 0, 2]]

For the list: [-5, -4, -4, -4, -3, -2, -1, -1, -1, 0, 0, 0, 1, 1, 1, 3, 4, 4, 5]
Triplets are: [[-5, 0, 5], [-5, 1, 4], [-4, -1, 5], [-4, 0, 4], [-4, 1, 3], [-3, -2, 5], [-3, -1, 4], [-3, 0, 3], [-2, -1, 3], [-2, 1, 1], [-1, 0, 1], [0, 0, 0]]

24) There is an array arr, which contains only non-negative integers (x1, x2, x3, ..., xn). Each of which represents the coordinate (j, xj). 'n' vertical lines are stretched such that the two endpoints of the line j is at (j, xj) and (j, 0). Find such two lines, which simultaneously with the x-axis creates a container, such that the container fetches the maximum amount of water. Assume that the water can be stored in the 2-D container. Note that slanting the container is not allowed.

Example: 1

arr = {5, 1, 2, 3};

Ans: 9

Explanation: There are 4 vertical lines in the given array, which are of height 5, 1, 2, and 3, respectively. Also, 5 and 3 are 3 distances apart. So, the capacity is min(5, 3) * 3 = 9. If we take any other pair of the vertical lines, we do not get a capacity of more than 9.

FileName: ContainerCapacity.java

// import statement
import java.util.*;

public class ContainerCapacity 
{
// a method that finds the maximum capacity
public int findMaxCapacity(ArrayList<Integer> height) 
{
int len = height.size();
int low = 0;
int high = len -1 ;  
int maxArea = 0;  
while (low < high) 
{  
maxArea = Math.max(maxArea, (high - low) * Math.min(height.get(low), height.get(high)));  
if (height.get(low) < height.get(high)) 
{  
low = low + 1;  
} 
else 
{  
high = high - 1;  
}  
}  
return maxArea;
}
    
// main method
public static void main(String argvs[])
{

// creating an object of the class ContainerCapacity 
ContainerCapacity obj = new ContainerCapacity();
ArrayList<Integer> al = new ArrayList<Integer>
(
Arrays.asList(5, 1, 2, 3)
);

int capacity = obj.findMaxCapacity(al);

System.out.println("For the list: " + al);
System.out.println("The maximum capacity is: " + capacity + "\n");

}
}

Output:

For the list: [5, 1, 2, 3]
The maximum capacity is: 9

25) An array arr of n integers is given. x1, x2 ,..., xn and an integer J. Return the count of unique numbers present in all windows whose size is J.

Example: 1

arr = {5, 1, 2, 3, 2, 5, 9, 8, 0, 0, 0}; J = 3

Ans: {3, 3, 2, 3, 3, 3, 3, 2, 1}

Explanation: All the windows of size J, which is 3, are:

{5, 1, 2} ---> 3 unique numbers

{1, 2, 3} ---> 3 unique numbers

{2, 3, 2} ---> 2 unique numbers

{3, 2, 5} ---> 3 unique numbers

{2, 5, 9} ---> 3 unique numbers

{5, 9, 8} ---> 3 unique numbers

{9, 8, 0} ---> 3 unique numbers

{8, 0, 0} ---> 2 unique numbers

{0, 0, 0} ---> 1 unique number

If we make a list of unique elements, we get {3, 3, 2, 3, 3, 3, 3, 2, 1}.

FileName: UniqueNumbers.java

// import statement
import java.util.*;

public class UniqueNumbers 
{
// a method that finds count of unique numbers in the window of size B
public ArrayList<Integer> uniqueNums(ArrayList<Integer> A, int B) 
{
        
HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();

int i = 0;
int j = 0;
ArrayList<Integer> result = new ArrayList<Integer>();

while(j < A.size())
{
hm.put(A.get(j), hm.getOrDefault(A.get(j), 0) + 1);

if(B<(j - i + 1))
{

hm.put(A.get(i), hm.getOrDefault(A.get(i), 0)-1);

if(hm.get(A.get(i))==0)
hm.remove(A.get(i));

i = i + 1; 
}
if(B==(j-i+1))
{

result.add(hm.size());
}
j = j + 1;
}
return result;
}
    
// main method
public static void main(String argvs[])
{

// creating an object of the class UniqueNumbers 
UniqueNumbers obj = new UniqueNumbers();
ArrayList<Integer> al = new ArrayList<Integer>
(
Arrays.asList(5, 1, 2, 3, 2, 5, 9, 8, 0, 0, 0)
);
Integer J = 3;


System.out.println("For the list: " + al);
al = obj.uniqueNums(al, J);

System.out.println("The list of unique numbers are: " + al + "\n");


al = new ArrayList<Integer>
(
Arrays.asList(5, 6, 7, 3, 3, 3, 1)
);
J = 1;

System.out.println("For the list: " + al);
al = obj.uniqueNums(al, J);

System.out.println("The list of unique numbers are: " + al + "\n");

}
}

Output:

For the list: [5, 1, 2, 3, 2, 5, 9, 8, 0, 0, 0]
The list of unique numbers are: [3, 3, 2, 3, 3, 3, 3, 2, 1]

For the list: [5, 6, 7, 3, 3, 3, 1]
The list of unique numbers are: [1, 1, 1, 1, 1, 1, 1]

26) An array arr containing only integers is given. Find 4 indices from the array arr such that arr[i] + arr[j] = arr[k] + arr[l] where i, j, k, &, l are the 4 indices. In the case of multiple answers, display any one set of 4 indices, which satisfies the given condition. Note that all the indices have to be unique.

Example: 1

arr = {-2, 0, 2, 4, -2, -4};

Ans: {0, 1, 2, 5}

Explanation: Values at the indices 0, 1, 2, and, 5 are -2, 0, 2, and, -4 respectively, and

-2 + 0 = 2 + -4 => 2. Other answer can be {0, 2, 3, 5}, or {1, 2, 3, 4}

FileName: EqualSum.java

// import statement
import java.util.*;

public class EqualSum 
{
public ArrayList<Integer> findInidices(ArrayList<Integer> A) 
{
// a map whose key is an integer and value is an array list
// the array list contains the indices such that sum of values 
// at those indices is equal to the key
// for example - A = [9, 4, 3, 2]
// map[13, [0, 1]];
// Now, 13 = A[0] + A[1] = 9 + 4 = 13
Map<Integer, ArrayList<Integer>> map = new HashMap<>();

// for storing those 4 indices such that A[i] + A[j] = A[k] + A[l]
ArrayList<Integer> result = new ArrayList<>();
for(int i = 0; i < A.size() - 1; i++)
{
for(int j = i + 1; j < A.size(); j++)
{
int sum = A.get(i) + A.get(j);
if(map.containsKey(sum))
{
// the k and l must be unique
// it is obivous that A[i] + A[j] = A[j] + A[i]
// 
int k = map.get(sum).get(0);
int l = map.get(sum).get(1);
if(k == i || k == j || l == i || l == j) 
{
continue;
}
map.get(sum).addAll(Arrays.asList(i,j));
}
else map.put(sum,new ArrayList<>(Arrays.asList(i,j)));
}
}
for(int i = 0;i < A.size() - 1; i++)
{
for(int j = i + 1; j < A.size(); j++)
{
int sum = A.get(i) + A.get(j);
// size greater than two means 
// we have found our four indices
if(map.get(sum).size() > 2)
{
result.addAll(Arrays.asList(i, j, map.get(sum).get(2), map.get(sum).get(3)));
return result;
}
}
}
return new ArrayList<>();
}

public static void main(String args[])
{ 
// creating an object of the class EqualSum
EqualSum obj = new EqualSum();


ArrayList<Integer> al = new ArrayList<Integer>
(
Arrays.asList(-2, 0, 2, 4, -2, -4)
);

System.out.println("For the list: " + al);
al = obj.findInidices(al);

System.out.println("The list of indices are: " + al + "\n");

al = new ArrayList<Integer>
(
Arrays.asList(2, 4, 5, 9, -1, 15, 7)
);

System.out.println("For the list: " + al);
al = obj.findInidices(al);

System.out.println("The list of indices are: " + al + "\n");


}
}

Output:

For the list: [-2, 0, 2, 4, -2, -4]
The list of indices are: [0, 1, 2, 5]

For the list: [2, 4, 5, 9, -1, 15, 7]
The list of indices are: [0, 1, 4, 6]

27) A string str and a string X are given. Look for the minimum window in str, which contains all the characters in X. The time complexity has to be linear. Note that the size of the window has to be equal to or greater than the size of string X.

Example: 1

S = "APPLBEXODEBLBNC"

X = "LNC"

Ans: "LBNC"

Explanation: Any other window will take more characters. The window of minimum size is mentioned in the answer.

FileName: SmallestWindow.java

// import statement
import java.util.*;

public class SmallestWindow 
{

    int[] a;
    int[] b;
public String minWindow(String A, String B) 
{
// for storing the frequency of characters
a = new int[256];
b = new int[256];
for(char c: B.toCharArray())
{
// storing the frequency of occurrance of 
// characters in the array b 
b[(int)c]++;
}
int n = A.length();
int l = 0;
int x = -1;
int y = n + 1;
for(int r = 0; r < n; r++)
{
char c = A.charAt(r);
a[(int)c]++;

while(l <= r && good(A.charAt(l)))
{
a[(int)A.charAt(l)]--;
l = l + 1;
}
if(good() && (r - l) < (y - x))
{
y = r;
x = l;
}

}

if(x == -1 && y == n + 1)
{
return "";
}

return A.substring(x, y + 1);

}
public boolean good(char c)
{
for(int i = 0; i < 256; i++)
{
if(a[i] < b[i])
{
return false;
}
}

return (a[(int)c] - b[(int)c] >= 1);
}
public boolean good()
{
// frequency of occurrance charcters in the String A 
// has to be greater than or equal to the frequency of characters 
// present in the string B
for(int i = 0; i < 256; i++)
{
if(a[i] < b[i])
{
return false;
}
}

return true;
}
    

// main method
public static void main(String args[])
{ 

// creating an object of the class SmallestWindow
SmallestWindow obj = new SmallestWindow();

String str = "APPLBEXODEBLBNC";
String t = "LNC";

String ans = obj.minWindow(str, t);

str = "'APPLBEXODEBLBNC'";
System.out.println("For the string: " + str);

System.out.println("The smallest window is: " + ans + "\n");

}
}

Output:

For the string: 'APPLBEXODEBLBNC'
The smallest window is: LBNC

28) A one-dimensional integer array arr of length l is given. What is the length of the longest subsequence, which is first increasing and then decreasing?

Example:

arr = {2, 11, 3, 10, 5, 4, 3, 2, 1}; l = 9

Ans: 8

Explanation: The longest subsequence which is increasing and then decreasing is {2, 3, 10, 5, 4, 3, 2, 1}. There are 8 elements in it. Hence, the answer is 8.

FileName: LongestSubsequence.java

// import statement
import java.util.*;

public class LongestSubsequence 
{
// DO NOT MODIFY THE LIST. IT IS READ ONLY
public int longestSubsequenceLength(final List<Integer> A) 
{
// list for containing the total number of elements in the increasing part
List<Integer> leftLIS = new ArrayList<>();

// list for containing the total number of elements in the decreasing part
List<Integer> rightLIS = new ArrayList<>();

if(A.isEmpty())
{
return 0;
}

int size = A.size();

// initializing the array
for(int i = 0 ; i < size ; i++) 
{
leftLIS.add(i, 1);
rightLIS.add(i, 1);
}

int max = 0;

// loop for considering the increasing part
for(int i = 0 ; i < size ; i++) 
{
for(int j = 0 ; j < i ; j++) 
{
if(A.get(i) > A.get(j)) 
{
leftLIS.set(i, Math.max(leftLIS.get(i), leftLIS.get(j) + 1));
}
}
}

// loop for considering the decreasing part
for(int i = size - 2 ; i >= 0; i -- )
{
for(int j = size - 1 ; j > i ; j--) 
{
if(A.get(i) > A.get(j)) 
{
rightLIS.set(i, Math.max(rightLIS.get(i), rightLIS.get(j) + 1));
}
}
}

// one part contains the increasing part
// other part contains the decreasing part
// Therefore, we have to combine the value from both the list
// The following loop does the same work and then finds the maximum
// In order to remove the redundant element -1 is used
for(int i = 0 ; i < size ; i++) 
{
// if max is less the sum of values from leftLIS, rightLIS, and - 1
// then update the max
if(max < (leftLIS.get(i) + rightLIS.get(i)) - 1) 
{
max = (leftLIS.get(i) + rightLIS.get(i)) - 1;
}
}
return max;
}


// main method
public static void main(String argvs[])
{
// creating an object of the class LongestSubsequence
LongestSubsequence obj = new LongestSubsequence();

ArrayList<Integer> al = new ArrayList<Integer>
(
Arrays.asList(2, 11, 3, 10, 5, 4, 3, 2, 1)
);

int val = obj.longestSubsequenceLength(al);

System.out.println("For the list: " + al);
System.out.println("The length of subsquence which is increasing and then decreasing is: " + val + "\n");

al = new ArrayList<Integer>
(
Arrays.asList(7, 6, 8, 10, 2, 5, 12, 30, 31, 20, 22, 18)
);

val = obj.longestSubsequenceLength(al);

System.out.println("For the list: " + al);
System.out.println("The length of subsequence which is increasing and then decreasing is: " + val);

}
}

Output:

For the list: [2, 11, 3, 10, 5, 4, 3, 2, 1]
The length of subsequence which is increasing and then decreasing is: 8

For the list: [7, 6, 8, 10, 2, 5, 12, 30, 31, 20, 22, 18]
The length of subsequence which is increasing and then decreasing is: 8

29) A set of coins X is given. Find out the number of ways one can make the sum S. Note that there is an infinite supply of the coins mentioned in the set X. Ensure that the space complexity is O(S). Note that ordering of coins should be ignored, i.e, 1 + 2 = 3 is one way; therefore, 2 + 1 = 3 won't be considered or vice versa. Also, set of coins will always be in ascending order.

Example:

X = {2, 3, 5, 7}; S = 15

Ans: 10

Explanation: There are 10 ways to get the sum S = 15. Following are those 10 ways:

2 + 2 + 2 + 2 + 2 + 2 + 3 = 15

2 + 2 + 2 + 3 + 3 + 3 = 15

2 + 2 + 2 + 2 + 2 + 5 = 15

2 + 3 + 5 + 5 = 15

2 + 2 + 3 + 3+ 5 = 15

2 + 2 + 2 + 2 + 7 = 15

2 + 3 + 3 + 7 = 15

3 + 3 + 3 + 3 + 3 = 15

3 + 5 + 7 = 15

5 + 5 + 5 = 15

FileName: CoinSum.java

// import statement
import java.util.*;

public class CoinSum 
{
public int countWays(ArrayList<Integer> A, int B) 
{
// the value of dp[j] represent the
// number of ways to get the sum j
int dp[] = new int[B + 1];
Arrays.fill(dp, 0);
        
dp[0] = 1;
        
for(int i = 0; i < A.size(); i++)
{
for(int j = A.get(i); j <= B; j++)
{
// finding the number of ways when 
// A[i] is included
dp[j] = dp[j] + dp[j - A.get(i)];
                
// finding number of ways when A[i]
// is excluded
dp[j] = dp[j];
}
}
        
return dp[B];
}

// main method
public static void main(String argvs[])
{
// creating an object of the class CoinSum
CoinSum obj = new CoinSum();

ArrayList<Integer> X = new ArrayList<Integer>
(
Arrays.asList(2, 3, 5, 7)
);

int sum = 15;


int ways = obj.countWays(X, sum);

System.out.println("For the set of coins: " + X);
System.out.println("There are " + ways + " ways to get the sum " + sum + "\n");

X = new ArrayList<Integer>
(
Arrays.asList(4, 6, 8, 9, 10)
);

sum = 90;


ways = obj.countWays(X, sum);

System.out.println("For the set of coins: " + X);
System.out.println("There are " + ways + " ways to get the sum " + sum);


}
}

Output:

For the set of coins: [2, 3, 5, 7]
There are 10 ways to get the sum 15

For the set of coins: [4, 6, 8, 9, 10]
There are 385 ways to get the sum 90

30) A chessboard of size R * C is given, where R represents the total number of rows, and C represents the total number of columns. Create a matrix arr, such that arr[x][y] represents the number of queen attacks occurring on the cell(x, y), assuming there is no queen present at the cell.

Note:

1) Queen moves any number of squares at a time in the vertical direction, horizontal direction, or diagonally on any chessboard. A queen is not a knight; therefore, it can not jump over other queens.

2) An array of R strings is given, each of the size C. The string only contains '0' and '1'. 1 represents queen, and 0 means empty cell. Thus, at any cell, either a queen is present, or the cell is empty.

3) The worst time complexity can not exceed O(R * C).

Example:

Suppose the chessboard be

[1 0 0]

[0 0 1]

[0 1 0]

Where 1 is the queen position and 0 is empty.

No queen attacks the cell(1, 1). Remember, we have to assume that no queen is present at the cell which we are evaluating for the attack.

3 attacks are coming from the queens to the cell (1, 2). One from the queen at the cell(1, 1), one from the queen at the cell(2, 3), and another from the cell(3, 2).

Queens at (2, 3) and (1, 1) attack the cell(1, 3). Note that we have considered 1-indexing this time.

Similarly, we can calculate the queen attack for other cells too.

The final matrix is:

[0, 3, 2]

[3, 3, 1]

[2, 1, 3]

FileName: QueenAttack.java

// import statement
import java.util.*;

public class QueenAttack 
{

public void fillQueens(int[][] grid,int i,int j,int n,int m,int[][] dp)
{
int[] dx = {-1, 0, 0, 1, -1, -1, 1, 1};
int[] dy = {0, -1, 1, 0, 1, -1, 1, -1};
for(int k = 0; k < 8; k++)
{
int x = i + dx[k];
int y = j + dy[k];
while(x >= 0 && x < n && y >= 0 && y < m)
{
dp[x][y]++;
if(grid[x][y] == 1)
break;
x += dx[k];
y += dy[k];
}
}
}

public ArrayList<ArrayList<Integer>> queenAttack(ArrayList<String> A) 
{
int n = A.size();
int m = A.get(0).length();
int[][] grid = new int[n][m];
for(int i = 0; i < n; i++)
{
for(int j = 0; j < m; j++)
{
grid[i][j] = (A.get(i).charAt(j) == '0') ? 0 : 1;
}
}
int[][] dp =new int[n][m];
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
if(grid[i][j] == 1)
{
fillQueens(grid,i,j,n,m,dp);
}
}
}

ArrayList<ArrayList<Integer>> arr=new ArrayList<>();
for(int i = 0;i < n; i++)
{
arr.add(new ArrayList<>());
for(int j = 0;j < m; j++)
{
arr.get(i).add(dp[i][j]);
}
}
return arr;
}


public int countWays(ArrayList<Integer> A, int B) 
{
// the value of dp[j] represent the
// number of ways to get the sum j
int dp[] = new int[B + 1];
Arrays.fill(dp, 0);

dp[0] = 1;

for(int i = 0; i < A.size(); i++)
{
for(int j = A.get(i); j <= B; j++)
{
// finding the number of ways when 
// A[i] is included
dp[j] = dp[j] + dp[j - A.get(i)];

// finding number of ways when A[i]
// is excluded
dp[j] = dp[j];
}
}

return dp[B];
}

// main method
public static void main(String argvs[])
{
// creating an object of the class QueenAttack
QueenAttack obj = new QueenAttack();

ArrayList<String> al = new ArrayList<String>
(
Arrays.asList("100", "001", "010")
);

ArrayList<ArrayList<Integer>> arr = obj.queenAttack(al);

System.out.println("For the chessboard: ");
for(String str : al)
{
System.out.println(str);
}
System.out.println();
System.out.println("The following matrix gives the number of queen attacks");

for(ArrayList<Integer> i : arr)
{
System.out.println(i);
}

}
}

Output:

For the chessboard: 
1 0 0
0 0 1
0 1 0

The following matrix gives the number of queen attacks
[0, 3, 2]
[3, 3, 1]
[2, 1, 3]

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

All Interview

Company Interview

Technical Interview

Web Interview

PHP Interview

.Net Interview

Java Interview

Database Interview

Programming Interview Questions

3) Given a read-only array arr of size s. Find out the number of ways one can divide the array arr into 3 parts such that the sum of each part is equal.

4) An array arr of N integers X1, X2, X3, ...., Xn is given. You have to return the maximum value of f(a1, a2), where 0 ≤ a1, a2, < N. It is given that f(a1, a2) = |arr[a1] - a[a2]| + |a1 - a2|, where |y| represents the absolute value of y.

5) Find the next permutation of the number that is formed by the elements of the array arr of size s without changing the order of elements.

6) There is an array arr, which contains only non-negative numbers. Create the largest number using all of the non-negative numbers of the given array arr.

7) A 2-dimensional matrix containing m rows and m columns is given. The task is to do the rotation of the matrix by 90 degrees in a clockwise manner.

8) There is an array arr, which contains only non-negative numbers. Find the subarray of the smallest size from the given array arr, which gets sorted; then the whole array gets sorted.

9) An array arr with size sz, a key k, and the segment size s is given, such that s completely divides sz. Check whether each segment of the array arr of size s has the key k present or not.

10) Given a string, the task is to search the rank of the given string amongst its lexicographically sorted permutations. The characters of the given string may or may not be repeated. If the characters are repeated, one needs to look at the unique permutations and then determine the rank.

11) Given two sorted arrays, arr and arr1. Their size may not be or maybe equal. Find the median of these given arrays. Note that merging of the sorted arrays is not allowed.

Note: We are merging it here only for the explanation purpose. In the code, we will not merge the arrays.

Note: The linear search will also do the job here. However, its time complexity would be more as compared to the binary search.

13) Given an array arr whose size is s. The array arr is sorted in non-decreasing order. Also, an integer tar is given. Find whether the integer tar is present in the array arr or not. If present, find the starting and ending indices of the integer tar.

14) A string str is given. Find the minimum of characters added to the string str to make it a palindrome string. The characters must be added at the beginning of the string.

16) An integer array arr is given such that every number is repeated thrice, barring one, which is repeated only once. Return the number that is repeated only once.

17) An integer array arr is given. Rearrange array arr such that arr[i] = arr[arr[i]]. The space complexity must be O(1).

Note: if the O(1) space complexity condition is removed, then the problem is straightforward. One can create an array of the same size as of input array and can copy the values of a[a[i]] to the recently created array. The O(1) space complexity makes the problem tricky.

18) A positive number n is given. Find the number of trailing zeros that are present in the binary representation of the number.

19) A number n is given. Find the n^th number whose binary representation is a palindrome.

20) An array arr of integers is given. Also, a sliding window of size w is moving from the left side to the right side of the array. Thus, at a time, one can only watch w numbers. The task is to find the maximum for each window. Observe the following examples.

21) An arithmetic expression is given in Reverse Polish Notation. Evaluate the given expression.

22) A number n is given, which represents the total number of bits present in the code. The gray code always starts from 0. Display the sequence of the gray code.

23) An array arr containing n integers is given. Find all the unique triplets (x, y, and z) such that x + y + z = 0. Note that ordering of triplets does not matter, i.e., y + z + x or y + x + z is the same as x + y + z.

25) An array arr of n integers is given. x1, x2 ,..., xn and an integer J. Return the count of unique numbers present in all windows whose size is J.

27) A string str and a string X are given. Look for the minimum window in str, which contains all the characters in X. The time complexity has to be linear. Note that the size of the window has to be equal to or greater than the size of string X.

28) A one-dimensional integer array arr of length l is given. What is the length of the longest subsequence, which is first increasing and then decreasing?

30) A chessboard of size R * C is given, where R represents the total number of rows, and C represents the total number of columns. Create a matrix arr, such that arr[x][y] represents the number of queen attacks occurring on the cell(x, y), assuming there is no queen present at the cell.

You may also like:

Learn Latest Tutorials

Preparation

Trending Technologies

B.Tech / MCA

All Interview

Company Interview

Technical Interview

Web Interview

PHP Interview

.Net Interview

Java Interview

Database Interview

Programming Interview Questions

3) Given a read-only array arr of size s. Find out the number of ways one can divide the array arr into 3 parts such that the sum of each part is equal.

4) An array arr of N integers X1, X2, X3, ...., Xn is given. You have to return the maximum value of f(a1, a2), where 0 ≤ a1, a2, < N. It is given that f(a1, a2) = |arr[a1] - a[a2]| + |a1 - a2|, where |y| represents the absolute value of y.

5) Find the next permutation of the number that is formed by the elements of the array arr of size s without changing the order of elements.

6) There is an array arr, which contains only non-negative numbers. Create the largest number using all of the non-negative numbers of the given array arr.

7) A 2-dimensional matrix containing m rows and m columns is given. The task is to do the rotation of the matrix by 90 degrees in a clockwise manner.

8) There is an array arr, which contains only non-negative numbers. Find the subarray of the smallest size from the given array arr, which gets sorted; then the whole array gets sorted.

9) An array arr with size sz, a key k, and the segment size s is given, such that s completely divides sz. Check whether each segment of the array arr of size s has the key k present or not.

10) Given a string, the task is to search the rank of the given string amongst its lexicographically sorted permutations. The characters of the given string may or may not be repeated. If the characters are repeated, one needs to look at the unique permutations and then determine the rank.

11) Given two sorted arrays, arr and arr1. Their size may not be or maybe equal. Find the median of these given arrays. Note that merging of the sorted arrays is not allowed.

Note: We are merging it here only for the explanation purpose. In the code, we will not merge the arrays.

Note: The linear search will also do the job here. However, its time complexity would be more as compared to the binary search.

13) Given an array arr whose size is s. The array arr is sorted in non-decreasing order. Also, an integer tar is given. Find whether the integer tar is present in the array arr or not. If present, find the starting and ending indices of the integer tar.

14) A string str is given. Find the minimum of characters added to the string str to make it a palindrome string. The characters must be added at the beginning of the string.

16) An integer array arr is given such that every number is repeated thrice, barring one, which is repeated only once. Return the number that is repeated only once.

17) An integer array arr is given. Rearrange array arr such that arr[i] = arr[arr[i]]. The space complexity must be O(1).

Note: if the O(1) space complexity condition is removed, then the problem is straightforward. One can create an array of the same size as of input array and can copy the values of a[a[i]] to the recently created array. The O(1) space complexity makes the problem tricky.

18) A positive number n is given. Find the number of trailing zeros that are present in the binary representation of the number.

19) A number n is given. Find the nth number whose binary representation is a palindrome.

20) An array arr of integers is given. Also, a sliding window of size w is moving from the left side to the right side of the array. Thus, at a time, one can only watch w numbers. The task is to find the maximum for each window. Observe the following examples.

21) An arithmetic expression is given in Reverse Polish Notation. Evaluate the given expression.

22) A number n is given, which represents the total number of bits present in the code. The gray code always starts from 0. Display the sequence of the gray code.

23) An array arr containing n integers is given. Find all the unique triplets (x, y, and z) such that x + y + z = 0. Note that ordering of triplets does not matter, i.e., y + z + x or y + x + z is the same as x + y + z.

25) An array arr of n integers is given. x1, x2 ,..., xn and an integer J. Return the count of unique numbers present in all windows whose size is J.

27) A string str and a string X are given. Look for the minimum window in str, which contains all the characters in X. The time complexity has to be linear. Note that the size of the window has to be equal to or greater than the size of string X.

28) A one-dimensional integer array arr of length l is given. What is the length of the longest subsequence, which is first increasing and then decreasing?

30) A chessboard of size R * C is given, where R represents the total number of rows, and C represents the total number of columns. Create a matrix arr, such that arr[x][y] represents the number of queen attacks occurring on the cell(x, y), assuming there is no queen present at the cell.

You may also like:

Learn Latest Tutorials

Preparation

Trending Technologies

B.Tech / MCA

19) A number n is given. Find the n^th number whose binary representation is a palindrome.