Interview Questions in Array
Question#01:
Write a java program to find duplicate elements in an array?
import java.util.HashMap;
import java.util.Map;
public class FindDuplicates {
public static void main(String[] args) {
int[] array = { 1, 2, 3, 4, 5, 3, 6, 7, 2, 8, 9, 5, 10, 11, 12, 9 };
Map<Integer, Integer> elementCount = new HashMap<>();
// Count occurrences of each element in the array
for (int num : array) {
if (elementCount.containsKey(num)) {
int count = elementCount.get(num);
elementCount.put(num, count + 1);
} else {
elementCount.put(num, 1);
// Print duplicate elements
System.out.println("Duplicate elements in the array are:");
for (Map.Entry<Integer, Integer> entry : elementCount.entrySet()) {
if (entry.getValue() > 1) {
System.out.println(entry.getKey());
}
Qusetion#02:
Write a java program to find second largest element in an array of integers?
public class SecondLargestElement {
public static void main(String[] args) {
int[] array = { 10, 6, 8, 3, 15, 7, 9, 4, 11 };
int secondLargest = findSecondLargest(array);
System.out.println("The second largest element in the array is: " + secondLargest);
public static int findSecondLargest(int[] array) {
int largest = Integer.MIN_VALUE;
int secondLargest = Integer.MIN_VALUE;
// Find the largest and second largest elements in the array
for (int num : array) {
if (num > largest) {
secondLargest = largest;
largest = num;
} else if (num > secondLargest && num != largest) {
secondLargest = num;
}
}
return secondLargest;
Question#03:
Maximum consecutive one's (or zeros) in a binary array?
To find the maximum consecutive ones (or zeros) in a binary array, you can use a simple loop to
traverse the array and keep track of the current consecutive count and the maximum
consecutive count found so far. Here's a Java program to find the maximum consecutive ones in
a binary array:
Program:
public class MaxConsecutiveOnes {
public static void main(String[] args) {
int[] binaryArray = {1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1};
int maxConsecutiveOnes = findMaxConsecutiveOnes(binaryArray);
System.out.println("Maximum consecutive ones: " + maxConsecutiveOnes);
public static int findMaxConsecutiveOnes(int[] nums) {
int maxConsecutiveOnes = 0;
int currentConsecutiveOnes = 0;
for (int num : nums) {
if (num == 1) {
currentConsecutiveOnes++;
maxConsecutiveOnes = Math.max(maxConsecutiveOnes, currentConsecutiveOnes);
} else {
currentConsecutiveOnes = 0;
return maxConsecutiveOnes;
Similarly, you can find the maximum consecutive zeros by modifying the condition
inside the loop to check for num == 0.
For example, if you have the binary array {1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1}, the program
will output:
Maximum consecutive ones: 4
Question#04:
Write a java program to find all the pairs of elements in an integer array whose sum is equal
to given number?
import java.util.HashMap;
import java.util.Map;
public class FindPairsWithSum {
public static void main(String[] args) {
int[] array = { 2, 4, 6, 8, 10, 12, 14, 16 };
int targetSum = 20;
findPairsWithSum(array, targetSum);
public static void findPairsWithSum(int[] nums, int targetSum) {
Map<Integer, Integer> map = new HashMap<>();
for (int num : nums) {
int complement = targetSum - num;
if (map.containsKey(complement)) {
System.out.println("Pair: " + num + ", " + complement);
map.put(num, num);
For example, if you have the integer array {2, 4, 6, 8, 10, 12, 14, 16} and the target sum is 20, the
program will output:
Pair: 10, 10
Pair: 12, 8
Question#05:
Write a java program to find continuous sub array whose sum is equal to a given
number?
public class FindSubarrayWithSum {
public static void main(String[] args) {
int[] array = { 1, 4, 20, 3, 10, 5 };
int targetSum = 33;
findSubarrayWithSum(array, targetSum);
public static void findSubarrayWithSum(int[] nums, int targetSum) {
int startIndex = 0;
int currentSum = nums[0];
for (int i = 1; i <= nums.length; i++) {
while (currentSum > targetSum && startIndex < i - 1) {
currentSum -= nums[startIndex];
startIndex++;
if (currentSum == targetSum) {
System.out.println("Subarray with the sum " + targetSum + " found from index " + startIndex + "
to " + (i - 1));
return;
if (i < nums.length) {
currentSum += nums[i];
}
System.out.println("No subarray found with the sum " + targetSum);
For example, if you have the integer array {1, 4, 20, 3, 10, 5} and the target sum is 33, the
program will output:
Subarray with the sum 33 found from index 2 to 4.
Question#06:
Write a java program to find intersection between two arrays?
import java.util.HashSet;
import java.util.Set;
public class ArrayIntersection {
public static void main(String[] args) {
int[] array1 = { 1, 2, 4, 5, 7 };
int[] array2 = { 2, 5, 8, 9 };
int[] intersection = findIntersection(array1, array2);
System.out.println("Intersection of the two arrays:");
for (int num : intersection) {
System.out.print(num + " ");
public static int[] findIntersection(int[] arr1, int[] arr2) {
Set<Integer> set = new HashSet<>();
for (int num : arr1) {
set.add(num);
Set<Integer> intersectionSet = new HashSet<>();
for (int num : arr2) {
if (set.contains(num)) {
intersectionSet.add(num);
int[] intersection = new int[intersectionSet.size()];
int index = 0;
for (int num : intersectionSet) {
intersection[index++] = num;
return intersection;
Question#07:
Write a java program to find intersection between two arrays?
import java.util.HashSet;
import java.util.Set;
public class ArrayIntersection {
public static void main(String[] args) {
int[] array1 = { 1, 2, 4, 5, 7 };
int[] array2 = { 2, 5, 8, 9 };
int[] intersection = findIntersection(array1, array2);
System.out.println("Intersection of the two arrays:");
for (int num : intersection) {
System.out.print(num + " ");
public static int[] findIntersection(int[] arr1, int[] arr2) {
Set<Integer> set = new HashSet<>();
for (int num : arr1) {
set.add(num);
Set<Integer> intersectionSet = new HashSet<>();
for (int num : arr2) {
if (set.contains(num)) {
intersectionSet.add(num);
int[] intersection = new int[intersectionSet.size()];
int index = 0;
for (int num : intersectionSet) {
intersection[index++] = num;
}
return intersection;
Question#08:
Write a java program to count occurrences of each element in an array?
import java.util.HashMap;
import java.util.Map;
public class CountOccurrences {
public static void main(String[] args) {
int[] array = { 2, 4, 5, 2, 6, 4, 7, 2, 8, 4, 9, 5 };
Map<Integer, Integer> elementCount = countOccurrences(array);
System.out.println("Occurrences of each element in the array:");
for (Map.Entry<Integer, Integer> entry : elementCount.entrySet()) {
System.out.println(entry.getKey() + " occurs " + entry.getValue() + " times.");
public static Map<Integer, Integer> countOccurrences(int[] arr) {
Map<Integer, Integer> elementCount = new HashMap<>();
for (int num : arr) {
elementCount.put(num, elementCount.getOrDefault(num, 0) + 1);
return elementCount;
For example, if you have an array {2, 4, 5, 2, 6, 4, 7, 2, 8, 4, 9, 5}, the program
will output:
Occurrences of each element in the array:
2 occurs 3 times.
4 occurs 3 times.
5 occurs 2 times.
6 occurs 1 times.
7 occurs 1 times.
8 occurs 1 times.
9 occurs 1 times.
Question#09:
Find a rotation with maximum hamming distance?
public class MaxHammingDistanceRotation {
public static void main(String[] args) {
int[] array = { 2, 4, 6, 8 };
int maxHammingDistance = findMaxHammingDistanceRotation(array);
System.out.println("Maximum Hamming distance: " + maxHammingDistance);
}
public static int findMaxHammingDistanceRotation(int[] arr) {
int n = arr.length;
int maxHammingDistance = 0;
// Create a duplicate array to rotate
int[] rotatedArray = new int[n];
System.arraycopy(arr, 0, rotatedArray, 0, n);
// Check all possible rotations and calculate Hamming distance
for (int i = 0; i < n; i++) {
int hammingDistance = 0;
for (int j = 0; j < n; j++) {
if (arr[j] != rotatedArray[j]) {
hammingDistance++;
maxHammingDistance = Math.max(maxHammingDistance, hammingDistance);
// Rotate the array by one position
int temp = rotatedArray[0];
System.arraycopy(rotatedArray, 1, rotatedArray, 0, n - 1);
rotatedArray[n - 1] = temp;
return maxHammingDistance;
}
For example, if you have an array {2, 4, 6, 8}, the program will output:
Maximum Hamming distance: 4
In this case, the maximum Hamming distance is achieved when the array is rotated by 2
positions to become {6, 8, 2, 4}.
Question#10:
Count distinct element in every k size window?
import java.util.HashMap;
import java.util.Map;
public class CountDistinctInWindow {
public static void main(String[] args) {
int[] array = { 1, 2, 1, 3, 4, 2, 3 };
int k = 4;
countDistinctInWindow(array, k);
public static void countDistinctInWindow(int[] arr, int k) {
Map<Integer, Integer> elementCount = new HashMap<>();
// Process the first window of size k
for (int i = 0; i < k; i++) {
elementCount.put(arr[i], elementCount.getOrDefault(arr[i], 0) + 1);
}
// Print the count of distinct elements in the first window
System.out.println("Window 0: " + elementCount.size());
// Process the remaining windows
for (int i = k; i < arr.length; i++) {
// Remove the first element of the previous window
int firstElement = arr[i - k];
if (elementCount.get(firstElement) == 1) {
elementCount.remove(firstElement);
} else {
elementCount.put(firstElement, elementCount.get(firstElement) - 1);
// Add the new element in the current window
elementCount.put(arr[i], elementCount.getOrDefault(arr[i], 0) + 1);
// Print the count of distinct elements in the current window
System.out.println("Window " + (i - k + 1) + ": " + elementCount.size());
For example, if you have an array {1, 2, 1, 3, 4, 2, 3} and k = 4, the program will
output:
Window 0: 3
Window 1: 3
Window 2: 3
Window 3: 3
Window 4: 4
Question#11:
Print duplicate characters from a string?
import java.util.HashMap;
import java.util.Map;
public class PrintDuplicateCharacters {
public static void main(String[] args) {
String inputString = "Hello, World!";
printDuplicateCharacters(inputString);
public static void printDuplicateCharacters(String str) {
Map<Character, Integer> charCount = new HashMap<>();
// Count occurrences of each character in the string
for (char ch : str.toCharArray()) {
if (Character.isLetter(ch) || Character.isDigit(ch)) { // Ignore non-alphanumeric characters
charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
// Print characters with count greater than 1 (i.e., duplicates)
System.out.println("Duplicate characters in the string:");
for (Map.Entry<Character, Integer> entry : charCount.entrySet()) {
if (entry.getValue() > 1) {
System.out.println(entry.getKey() + " - " + entry.getValue() + " occurrences");
For example, if you have the input string "Hello, World!", the program will output:
Duplicate characters in the string:
l - 3 occurrences
o - 2 occurrences
Question#12:
Check if two strings are anagrams or not?
import java.util.HashMap;
import java.util.Map;
public class AnagramChecker {
public static void main(String[] args) {
String str1 = "listen";
String str2 = "silent";
boolean areAnagrams = checkAnagrams(str1, str2);
if (areAnagrams) {
System.out.println("The two strings are anagrams.");
} else {
System.out.println("The two strings are not anagrams.");
public static boolean checkAnagrams(String str1, String str2) {
if (str1.length() != str2.length()) {
return false;
Map<Character, Integer> charCount = new HashMap<>();
// Count occurrences of characters in the first string
for (char ch : str1.toCharArray()) {
charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
// Check occurrences of characters in the second string
for (char ch : str2.toCharArray()) {
int count = charCount.getOrDefault(ch, 0);
if (count == 0) {
return false;
charCount.put(ch, count - 1);
// If all characters have been matched, the strings are anagrams
return true;
}
Question#13:
Check for balanced brackets?
import java.util.Stack;
public class BalancedBracketsChecker {
public static void main(String[] args) {
String inputString1 = "{[()]}";
String inputString2 = "{[(])}";
String inputString3 = "{{[[(())]]}}";
System.out.println(inputString1 + " is " + (isBalancedBrackets(inputString1) ? "balanced" : "not
balanced"));
System.out.println(inputString2 + " is " + (isBalancedBrackets(inputString2) ? "balanced" : "not
balanced"));
System.out.println(inputString3 + " is " + (isBalancedBrackets(inputString3) ? "balanced" : "not
balanced"));
public static boolean isBalancedBrackets(String str) {
Stack<Character> stack = new Stack<>();
for (char ch : str.toCharArray()) {
if (ch == '(' || ch == '[' || ch == '{') {
stack.push(ch);
} else if (ch == ')' || ch == ']' || ch == '}') {
if (stack.isEmpty()) {
return false; // Unbalanced closing bracket
char top = stack.pop();
if (!((ch == ')' && top == '(') || (ch == ']' && top == '[') || (ch == '}' && top == '{'))) {
return false; // Mismatched brackets
return stack.isEmpty(); // If the stack is empty, all brackets are balanced
For example, if you have the strings "{[()]}", "{[(])}", and "{{[[(())]]}}", the program will
output:
{[()]} is balanced
{[(])} is not balanced
{{[[(())]]}} is balanced
Question#14:
Count number of substrings?
To count the number of substrings in a given string, you can use the following formula:
Number of substrings = n*(n+1)/2
where "n" is the length of the string.
Here's a Java program to calculate the number of substrings in a given string:
public class CountSubstrings {
public static void main(String[] args) {
String inputString = "abcde";
int numberOfSubstrings = countSubstrings(inputString);
System.out.println("Number of substrings: " + numberOfSubstrings);
public static int countSubstrings(String str) {
int n = str.length();
return n * (n + 1) / 2;
In this program, we have a function countSubstrings that takes a string as input and
calculates the number of substrings using the formula mentioned above.
For example, if you have the string "abcde", the program will output:
Number of substrings: 15
This means there are 15 substrings in the string "abcde": "a", "b", "c", "d", "e", "ab", "bc",
"cd", "de", "abc", "bcd", "cde", "abcd", "bcde", and "abcde".
Question#15:
Check if a string is a rotated palindrome or not?
To check if a string is a rotated palindrome, we can follow these steps:
1. Concatenate the input string with itself to create a new string that contains all possible rotations of
the original string.
2. For each rotation of the original string in the new string, check if it is a palindrome.
If any of the rotations are palindromes, then the original string is a rotated palindrome. Otherwise, it is
not.
Here's a Java program to implement the above logic:
```java
public class RotatedPalindromeChecker {
public static void main(String[] args) {
String inputString = "noon";
boolean isRotatedPalindrome = isRotatedPalindrome(inputString);
if (isRotatedPalindrome) {
System.out.println("The string is a rotated palindrome.");
} else {
System.out.println("The string is not a rotated palindrome.");
public static boolean isRotatedPalindrome(String str) {
// Concatenate the input string with itself to create all possible rotations
String rotatedString = str + str;
// Check if any rotation is a palindrome
for (int i = 0; i < str.length(); i++) {
if (isPalindrome(rotatedString.substring(i, i + str.length()))) {
return true;
return false;
public static boolean isPalindrome(String str) {
int left = 0;
int right = str.length() - 1;
while (left < right) {
if (str.charAt(left) != str.charAt(right)) {
return false;
left++;
right--;
return true;
```
In this program, we have a function `isRotatedPalindrome`, which takes a string as input and checks if it
is a rotated palindrome. It concatenates the input string with itself to create all possible rotations and
then checks each rotation for palindrome property using the `isPalindrome` function.
The `isPalindrome` function checks if a given string is a palindrome. It uses two pointers (`left` and
`right`) to compare characters from the beginning and end of the string until they meet at the center.
For example, if you have the string "noon", the program will output:
To check if a string is a rotated palindrome, we can follow these steps:
1. Concatenate the input string with itself to create a new string that contains all possible rotations of
the original string.
2. For each rotation of the original string in the new string, check if it is a palindrome.
If any of the rotations are palindromes, then the original string is a rotated palindrome. Otherwise, it is
not.
Here's a Java program to implement the above logic:
```java
public class RotatedPalindromeChecker {
public static void main(String[] args) {
String inputString = "noon";
boolean isRotatedPalindrome = isRotatedPalindrome(inputString);
if (isRotatedPalindrome) {
System.out.println("The string is a rotated palindrome.");
} else {
System.out.println("The string is not a rotated palindrome.");
public static boolean isRotatedPalindrome(String str) {
// Concatenate the input string with itself to create all possible rotations
String rotatedString = str + str;
// Check if any rotation is a palindrome
for (int i = 0; i < str.length(); i++) {
if (isPalindrome(rotatedString.substring(i, i + str.length()))) {
return true;
return false;
public static boolean isPalindrome(String str) {
int left = 0;
int right = str.length() - 1;
while (left < right) {
if (str.charAt(left) != str.charAt(right)) {
return false;
left++;
right--;
return true;
```
In this program, we have a function `isRotatedPalindrome`, which takes a string as input and checks if it
is a rotated palindrome. It concatenates the input string with itself to create all possible rotations and
then checks each rotation for palindrome property using the `isPalindrome` function.
The `isPalindrome` function checks if a given string is a palindrome. It uses two pointers (`left` and
`right`) to compare characters from the beginning and end of the string until they meet at the center.
For example, if you have the string "noon", the program will output:
```
The string is a rotated palindrome.
```
Since "noon" is a palindrome and its rotations "onon" and "noon" are also palindromes, it is a rotated
palindrome.is a rotated palindrome.
```
Since "noon" is a palindrome and its rotations "onon" and "noon" are also palindromes, it is a rotated
palindrome.
Question#16:
Find all possible palindromic substring of a string?
import java.util.ArrayList;
import java.util.List;
public class PalindromicSubstrings {
public static void main(String[] args) {
String inputString = "abbaaabb";
List<String> palindromicSubstrings = findAllPalindromicSubstrings(inputString);
System.out.println("Palindromic Substrings:");
for (String substring : palindromicSubstrings) {
System.out.println(substring);
public static List<String> findAllPalindromicSubstrings(String str) {
List<String> palindromicSubstrings = new ArrayList<>();
for (int i = 0; i < str.length(); i++) {
// Check for odd-length palindromes
findPalindromes(str, i, i, palindromicSubstrings);
// Check for even-length palindromes
findPalindromes(str, i, i + 1, palindromicSubstrings);
return palindromicSubstrings;
public static void findPalindromes(String str, int left, int right, List<String> result) {
while (left >= 0 && right < str.length() && str.charAt(left) == str.charAt(right)) {
result.add(str.substring(left, right + 1));
left--;
right++;
}
}
For example, if you have the string "abbaaabb", the program will output:
Palindromic Substrings:
bb
abb
aabbaa
Question#17:
Find the longest substrings of a string containing distinct characters?
import java.util.HashMap;
import java.util.Map;
public class LongestDistinctSubstring {
public static void main(String[] args) {
String inputString = "abcaabbcd";
String longestDistinctSubstring = findLongestDistinctSubstring(inputString);
System.out.println("Longest distinct substring: " + longestDistinctSubstring);
public static String findLongestDistinctSubstring(String str) {
int n = str.length();
int maxLength = 0;
int start = 0;
int end = 0;
int maxStart = 0;
Map<Character, Integer> charIndexMap = new HashMap<>();
while (end < n) {
char ch = str.charAt(end);
if (charIndexMap.containsKey(ch) && charIndexMap.get(ch) >= start) {
// Character repeats, move the start pointer to its next position
start = charIndexMap.get(ch) + 1;
charIndexMap.put(ch, end);
int currentLength = end - start + 1;
if (currentLength > maxLength) {
maxLength = currentLength;
maxStart = start;
end++;
return str.substring(maxStart, maxStart + maxLength);
For example, if you have the input string "abcaabbcd", the program will output:
Longest distinct substring: abc
Question#18:
Determine whether a string is a palindrome or not?
public class PalindromeChecker {
public static void main(String[] args) {
String inputString1 = "level";
String inputString2 = "hello";
System.out.println(inputString1 + " is " + (isPalindrome(inputString1) ? "a palindrome" : "not a
palindrome"));
System.out.println(inputString2 + " is " + (isPalindrome(inputString2) ? "a palindrome" : "not a
palindrome"));
}
public static boolean isPalindrome(String str) {
int left = 0;
int right = str.length() - 1;
while (left < right) {
if (str.charAt(left) != str.charAt(right)) {
return false;
left++;
right--;
return true;
For example, if you have the strings "level" and "hello", the program will output:
level is a palindrome
hello is not a palindrome
Question#19:
Find first k non-repeating characters in a string in a single traversal?
import java.util.LinkedHashMap;
import java.util.Map;
public class FirstKNonRepeatingCharacters {
public static void main(String[] args) {
String inputString = "aabbcddee";
int k = 3;
String result = findFirstKNonRepeatingCharacters(inputString, k);
System.out.println("First " + k + " non-repeating characters: " + result);
public static String findFirstKNonRepeatingCharacters(String str, int k) {
Map<Character, Integer> charCountMap = new LinkedHashMap<>();
// Count the occurrences of each character in the string
for (char ch : str.toCharArray()) {
charCountMap.put(ch, charCountMap.getOrDefault(ch, 0) + 1);
// Find the first k non-repeating characters
StringBuilder result = new StringBuilder();
for (Map.Entry<Character, Integer> entry : charCountMap.entrySet()) {
if (entry.getValue() == 1 && k > 0) {
result.append(entry.getKey());
k--;
return result.toString();
}
For example, if you have the input string "aabbcddee" and k = 3, the program will output:
First 3 non-repeating characters: cde
Question#20:
Check if a repeated subsequence is present in a string or not?
public class RepeatedSubsequenceChecker {
public static void main(String[] args) {
String inputString = "ABCDACBD";
boolean hasRepeatedSubsequence = checkRepeatedSubsequence(inputString);
if (hasRepeatedSubsequence) {
System.out.println("The string has a repeated subsequence.");
} else {
System.out.println("The string does not have a repeated subsequence.");
public static boolean checkRepeatedSubsequence(String str) {
int n = str.length();
boolean[][] dp = new boolean[n][n];
for (int len = 1; len < n; len++) {
for (int i = 0; i < n - len; i++) {
int j = i + len;
if (str.charAt(i) == str.charAt(j) && !dp[i][j]) {
dp[i][j] = true;
} else {
for (int k = i + 1; k < j; k++) {
if (dp[i][k] && dp[k][j]) {
return true;
return false;
For example, if you have the input string "ABCDACBD", the program will output:
The string has a repeated subsequence.
