Crack Array Programming: A

Tactical Guide for Software Testers

Your Complete Path to Mastering Array Programs for
Interviews
Created By: Amarendra Pani

ni
Pa
ra
Why This Guide is Unique
Professional Coding Standards: Follow industry standards with clean and modular code.
d
Step-by-Step Explanations: Clear breakdowns of inputs, processing, and outputs to understand
actions and their purpose.
en

Comprehensive Comments: Fully commented code for beginners, with quick logic insights for
advanced users.

Multiple Solutions: Alternative approaches for complex problems to enhance problem-solving skills.
ar

Focus on Edge Cases: Covers tricky scenarios like empty arrays and null values, vital for interviews.

Real-World Coding Techniques: Utilizes modular functions and efficient data structures for interview
m

readiness.

JavaDoc Documentation: Well-documented methods and clear comments for easy understanding.

Ready to Start?
A

Open your IDE, work through the problems, and build your confidence to crack
technical interviews.

Let’s Begin.
This guide isn’t just a document; it’s your secret weapon for
mastering array programming and getting hired.
1. How do you Remove the Duplicates from an Array Using HashSet

2. How do you delete duplicates from a sorted array using the index in Java?

3. How do you find the duplicate elements in an array using index in Java?

4. How do you find the duplicate elements in an array using a HashSet in Java?

5. How do you find the sum of all the elements in an array in Java?

6. How do you separately print the even and odd numbers in a given array in Java?

ni
7. How do you compare two arrays in Java without using any inbuilt methods?

8. How do you compare two arrays using predefined methods in Java?

Pa
9. How do you find the missing element in an array in Java?

10. How do you find the maximum and minimum elements in a given array in Java?
ra
11. How do you search for a given element in an array in Java?

12. How do you print the elements of an array in Java?

d
13. How do you sort the elements in an array using built-in functions in Java?
en

14. How do you reverse an array in Java using Java Collections?

15. How do you receive input from the user and save it into an array in Java?
ar

16. How do you reverse the elements of an array in Java?

17. How do you find the number of elements in a given array in Java?
m

18. How do you perform a right rotation of an array by n positions in Java?

A

19. How do you perform a left rotation of an array by n positions in Java?

20. How do you swap the first and last elements of an array in Java?

21. How do you multiply the corresponding elements of two arrays in Java?

22. How do you find the first occurrence of a given element in an array without using a
specific algorithm in Java?
23. How do you find the first occurrence of a given element in a sorted array using an
algorithm in Java?

24. How do you sort an array in ascending order using built-in functions in Java?

25. How do you sort an array in descending order using built-in functions in Java?

26. How do you join two arrays in Java? Provide all possible solutions.

27. How do you calculate the average of an array in Java using a simple loop, Java 8 streams,
and the Google Guava library?

ni
28. How do you shift all zero elements to the right side of the array in Java?

Pa
29. How do you check the equality of two arrays in Java?

30. How do you search for an element in an array in Java?

31. How do you reverse an array in Java without using any built-in method and without using
ra
any extra array?

32. How do you find the second largest element in an array in Java?
d
33. How do you find the second smallest element from an array in Java?
en

34. How do you find all possible pairs of elements in an array in Java?

35. How do you find the first repeating element in an array in Java?
ar

36. How do you find the first occurrence and last occurrence of an element in an array in
Java?
m

37. How do you find the common elements in multiple arrays in Java?
A

38. How do you rearrange the positive and negative elements of an array in Java?

39. How do you find the second smallest element in an array without sorting in Java?

40. How do you segregate an array in Java?

41. How do you remove consecutive duplicates from an array in Java?

42. How do you count all possible pairs from an array in Java?
1. Question: How do you Remove the Duplicates from an
Array Using HashSet

Key Concept:

In this problem, you're asked to remove duplicate elements from an array. Using a HashSet is
an efficient approach because it automatically handles duplicate elements. A HashSet in Java
only allows unique elements, so when we add elements from the array into the HashSet, it
will automatically discard any duplicates.

ni
Solution:

Pa
package array;

import java.util.HashSet;

import java.util.Scanner;
ra
import java.util.Set;

import java.util.Arrays;
d
public class RemoveDuplicatesFromArray {
en

public static void main(String[] args) {

// Step 1: Accept input for the array

ar

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements in the array: ");

m

int n = scanner.nextInt(); // Take input for the size of the array

int[] arr = new int[n]; // Create an array of the given size

A

System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

// Step 2: Use a HashSet to remove duplicates

Set<Integer> uniqueElements = new HashSet<>(); // Set to hold unique elements

for (int num : arr) {

uniqueElements.add(num); // HashSet automatically handles duplicates

// Step 3: Convert Set back to Array (Optional)

int[] resultArray = new int[uniqueElements.size()];

int index = 0;

for (int num : uniqueElements) {

ni
resultArray[index++] = num;

Pa
// Step 4: Output the result

System.out.println("Array after removing duplicates: " +

Arrays.toString(resultArray));

// Closing scanner to avoid memory leaks

ra
scanner.close();
d
}

}
en

Explanation of Steps:
ar

1. Input Handling: First, the program takes input for the array size and its elements.
m

2. Using HashSet: All elements of the array are added to the HashSet. Since a HashSet
does not allow duplicate values, any duplicates in the array are automatically
A

removed.

3. Conversion to Array (Optional): We can convert the HashSet back to an array if

needed, although we can directly work with the Set.

4. Edge Case Handling: If the array contains only one element or no duplicates, the
program still works correctly.
Input/Output Examples:

• Example 1:

o Input: Enter the number of elements: 6

▪ Elements: 1, 2, 2, 3, 4, 4

o Output: Array after removing duplicates: [1, 2, 3, 4]

• Example 2 (All Unique):

ni
o Input: Enter the number of elements: 5

▪ Elements: 10, 20, 30, 40, 50

Pa
o Output: Array after removing duplicates: [10, 20, 30, 40, 50]

• Example 3 (All Duplicates):

o
ra
Input: Enter the number of elements: 4

▪ Elements: 5, 5, 5, 5
d
o Output: Array after removing duplicates: [5]
en

Edge Cases:

1. Empty Array: If the array has no elements, the program should gracefully handle it by
ar

outputting an empty result.

2. Single Element Array: If the array has only one element, the result is the same as the
m

input because there are no duplicates.

A

2. Question: How do you delete duplicates from a sorted

array using the index in Java?

Key Concept:

When the array is sorted, the duplicates will always be next to each other. This allows us to
traverse the array using a two-pointer technique. One pointer (index) will keep track of the
position where the unique element should be placed, while the other pointer will scan
through the array to check for duplicates.

Solution:

package array;

import java.util.Scanner;

import java.util.Arrays;

ni
public class RemoveDuplicatesSortedArray {

Pa
public static void main(String[] args) {

// Step 1: Accept input for the sorted array

Scanner scanner = new Scanner(System.in);

ra
System.out.println("Enter the number of elements in the sorted array: ");
d
int n = scanner.nextInt(); // Take input for the size of the array
en

int[] arr = new int[n]; // Create an array of the given size

System.out.println("Enter " + n + " elements of the sorted array (sorted in non-

decreasing order): ");
ar

for (int i = 0; i < n; i++) {

m

arr[i] = scanner.nextInt(); // Input the elements into the array

}
A

// Step 2: If array is empty or contains only one element, no need to process

if (n == 0 || n == 1) {

System.out.println("Array after removing duplicates: " + Arrays.toString(arr));

return;

}
// Step 3: Use index to keep track of the unique elements

int index = 1; // Start at 1 because the first element is always unique

// Traverse the array and compare each element with the previous one

for (int i = 1; i < n; i++) {

if (arr[i] != arr[i - 1]) {

arr[index] = arr[i]; // Place the unique element at the index position

ni
index++; // Move the index forward

Pa
}

// Step 4: Create a result array with the unique elements

ra
int[] resultArray = Arrays.copyOfRange(arr, 0, index);
d
// Step 5: Output the result
en

System.out.println("Array after removing duplicates: " +

Arrays.toString(resultArray));

// Closing scanner to avoid memory leaks

ar

scanner.close();
m

}
A

Explanation of Steps:

1. Input Handling: The program takes input for the size and elements of a sorted array.

2. Handling Special Cases: If the array has only one element or is empty, no duplicates
need to be removed.

3. Two-pointer Approach:
 o The first pointer (index) tracks where to store unique elements.

o The second pointer (i) scans through the array, comparing each element with
the previous one.

o When a new unique element is found, it's placed at the current index
position.

4. Array Truncation: After the unique elements are identified, we use

Arrays.copyOfRange to create a new array containing only the unique elements.

ni
5. Edge Case Handling: If there are no duplicates or the array has one element, the
output remains unchanged.

Pa
Input/Output Examples:

• Example 1:

o
ra
Input: Enter the number of elements: 7

▪ Elements: 1, 1, 2, 2, 3, 3, 4
d
o Output: Array after removing duplicates: [1, 2, 3, 4]
en

• Example 2 (No Duplicates):

o Input: Enter the number of elements: 5

ar

▪ Elements: 10, 20, 30, 40, 50

o Output: Array after removing duplicates: [10, 20, 30, 40, 50]
m

• Example 3 (Edge Case - Single Element):

A

o Input: Enter the number of elements: 1

▪ Element: 42

o Output: Array after removing duplicates: [42]

Edge Cases:

1. Empty Array: If the input array is empty, the program should return an empty array.

2. Array with One Element: If the input array has only one element, the output is the
same as the input because there are no duplicates.

3. Question: How do you find the duplicate elements in an

ni
array using index in Java?

Key Concept:

Pa
In this problem, we need to identify the duplicate elements in an array. By using a two-loop
approach, we can compare each element of the array with the subsequent elements and
check for duplicates. This approach is simple but can be optimized using more advanced
ra
methods, like sorting or hashing.

Solution:
d
en

package array;

import java.util.Scanner;
ar

public class FindDuplicatesUsingIndex {

public static void main(String[] args) {

m

// Step 1: Accept input for the array

A

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

int[] arr = new int[n]; // Create an array of the given size

System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

// Step 2: Find and print duplicates

System.out.println("Duplicate elements in the array are: ");

boolean hasDuplicates = false;

ni
// Outer loop to pick each element

Pa
for (int i = 0; i < n; i++) {

// Inner loop to compare the current element with others

ra
for (int j = i + 1; j < n; j++) {

// If we find a duplicate, print it

d
if (arr[i] == arr[j]) {
en

System.out.print(arr[i] + " ");

hasDuplicates = true;
ar

break; // To avoid printing the same duplicate multiple times

m

}
A

if (!hasDuplicates) {

System.out.println("No duplicates found.");

// Closing scanner to avoid memory leaks

scanner.close();

Explanation of Steps:

1. Input Handling: The program takes input for the array size and its elements.

2. Two-Loop Comparison:

ni
o The outer loop picks one element at a time.

Pa
o The inner loop compares the current element with the subsequent elements
in the array.

o When a duplicate is found, it's printed, and the inner loop breaks to avoid
ra
printing the same duplicate again.

3. Edge Case Handling: If no duplicates are found, a message stating "No duplicates
d
found" is displayed.

Input/Output Examples:
en

• Example 1:
ar

o Input: Enter the number of elements: 6

▪ Elements: 1, 2, 2, 3, 4, 4
m

o Output: Duplicate elements in the array are: 2 4

• Example 2 (No Duplicates):

A

o Input: Enter the number of elements: 5

▪ Elements: 5, 10, 15, 20, 25

o Output: No duplicates found.

• Example 3 (Multiple Duplicates):

o Input: Enter the number of elements: 8

 ▪ Elements: 3, 3, 5, 7, 7, 7, 9, 9

o Output: Duplicate elements in the array are: 3 7 9

Edge Cases:

1. Empty Array: If the array is empty, no duplicates exist, and the program will print "No
duplicates found."

2. Single Element Array: If the array has only one element, the program will also print
"No duplicates found" as there are no duplicates.

ni
Time Complexity:

Pa
• The time complexity of this solution is O(n²) due to the nested loops, where n is the
number of elements in the array. For large arrays, this could be inefficient, but it is
simple and easy to understand for smaller inputs.
ra
4. Question: How do you find the duplicate elements in an
d
array using a HashSet in Java?
en

Key Concept:
ar

In this problem, we use a HashSet to efficiently find duplicates in an array. A HashSet only
allows unique elements. As we iterate through the array, if an element is already present in
the HashSet, we know it's a duplicate. This approach is more efficient than using nested
m

loops because it reduces the time complexity from O(n²) to O(n).

Solution:
A

package array;

import java.util.HashSet;

import java.util.Scanner;

public class FindDuplicatesUsingHashSet {

public static void main(String[] args) {

// Step 1: Accept input for the array

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

int[] arr = new int[n]; // Create an array of the given size

ni
System.out.println("Enter " + n + " elements of the array: ");

Pa
for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

}
ra
// Step 2: Use HashSet to find duplicates
d
HashSet<Integer> elements = new HashSet<>(); // Set to store unique elements
en

HashSet<Integer> duplicates = new HashSet<>(); // Set to store duplicates

for (int i = 0; i < n; i++) {

ar

if (!elements.add(arr[i])) {

// If add() returns false, the element is a duplicate

m

duplicates.add(arr[i]);
A

// Step 3: Output the result

if (duplicates.isEmpty()) {

System.out.println("No duplicates found.");

} else {

System.out.println("Duplicate elements in the array are: " + duplicates);

// Closing scanner to avoid memory leaks

scanner.close();

ni
}

Pa
Explanation of Steps:

1. Input Handling: The program takes input for the array size and elements.

2. Using HashSet:
ra
o The HashSet named elements is used to store unique elements.

If the element is already present in the HashSet (i.e., add() returns false), it is
d
o

added to the duplicates HashSet.

en

3. Output Handling:

o If the duplicates set is empty, no duplicates are found.

ar

o If duplicates are found, they are displayed.

m

Input/Output Examples:

• Example 1:
A

o Input: Enter the number of elements: 7

▪ Elements: 1, 2, 3, 4, 4, 5, 2

o Output: Duplicate elements in the array are: [2, 4]

• Example 2 (No Duplicates):

o Input: Enter the number of elements: 5

 ▪ Elements: 10, 20, 30, 40, 50

o Output: No duplicates found.

• Example 3 (Multiple Duplicates):

o Input: Enter the number of elements: 6

▪ Elements: 3, 3, 7, 7, 7, 9

o Output: Duplicate elements in the array are: [3, 7]

ni
Edge Cases:

1. Empty Array: If the array is empty, the program should print "No duplicates found."

Pa
2. Single Element Array: If the array has only one element, the program will print "No
duplicates found" as there are no duplicates.
ra
Time Complexity:

• The time complexity of this solution is O(n) where n is the number of elements in the
d
array. This is because HashSet operations like add() take constant time, making this
approach much more efficient than using nested loops.
en

5. Question: How do you find the sum of all the elements

ar

in an array in Java?
m

Key Concept:

In this problem, we need to calculate the sum of all elements in an array. The approach is
A

straightforward: initialize a variable to store the sum and then iterate through the array,
adding each element to the sum.

Solution:

package array;

import java.util.Scanner;
public class SumOfArrayElements {

public static void main(String[] args) {

// Step 1: Accept input for the array

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

ni
int[] arr = new int[n]; // Create an array of the given size

Pa
System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

ra
}
d
// Step 2: Initialize sum variable
en

int sum = 0;

// Step 3: Traverse the array and add each element to the sum
ar

for (int i = 0; i < n; i++) {

sum += arr[i]; // Accumulate sum

m

}
A

// Step 4: Output the sum

System.out.println("The sum of all elements in the array is: " + sum);

// Closing scanner to avoid memory leaks

scanner.close();

}
}

Explanation of Steps:

1. Input Handling: The program first asks the user to input the number of elements in
the array and then takes the array elements.

2. Sum Calculation:

o A variable sum is initialized to 0.

ni
o A for loop is used to iterate through the array and accumulate the sum of the
elements.

Pa
3. Output the Sum: After the loop, the sum is printed.

Input/Output Examples:

• Example 1:
ra
o Input: Enter the number of elements: 5
d
▪ Elements: 1, 2, 3, 4, 5
en

o Output: The sum of all elements in the array is: 15

• Example 2:
ar

o Input: Enter the number of elements: 4

▪ Elements: 10, -5, 15, 20

m

o Output: The sum of all elements in the array is: 40

• Example 3 (Single Element):

A

o Input: Enter the number of elements: 1

▪ Element: 42

o Output: The sum of all elements in the array is: 42

Edge Cases:

1. Empty Array: If the array is empty (n = 0), the sum is 0. In this case, the program can
handle the empty input without crashing.

2. Negative Elements: If the array contains negative numbers, they are correctly
included in the sum.

Time Complexity:

• The time complexity of this solution is O(n), where n is the number of elements in

ni
the array. This is because the array is traversed once.

Pa
6. Question: How do you separately print the even and
odd numbers in a given array in Java?
ra
Key Concept:
d
In this problem, we need to classify the elements of an array into even and odd numbers
and print them separately. An even number is divisible by 2, while an odd number is not. The
en

solution involves iterating through the array and checking whether each element is even or
odd using the modulus operator (%).
ar

Solution:

package array;
m

import java.util.Scanner;
A

public class EvenOddInArray {

public static void main(String[] args) {

// Step 1: Accept input for the array

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

int[] arr = new int[n]; // Create an array of the given size

System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

ni
// Step 2: Print the even numbers

Pa
System.out.println("Even numbers in the array are: ");

for (int i = 0; i < n; i++) {

if (arr[i] % 2 == 0) {
ra
System.out.print(arr[i] + " ");
d
}
en

System.out.println(); // Line break for better formatting

ar

// Step 3: Print the odd numbers

System.out.println("Odd numbers in the array are: ");

m

for (int i = 0; i < n; i++) {

A

if (arr[i] % 2 != 0) {

System.out.print(arr[i] + " ");

// Closing scanner to avoid memory leaks

scanner.close();

Explanation of Steps:

1. Input Handling: The program takes the array size and the array elements as input.

2. Classifying Even and Odd Numbers:

ni
o A for loop iterates through the array.

Pa
o For each element, we check if the number is divisible by 2 (arr[i] % 2 == 0). If
true, the number is even; otherwise, it is odd.

3. Printing Even and Odd Numbers: Two separate loops are used to print even and odd
ra
numbers.

Input/Output Examples:
d
• Example 1:
en

o Input: Enter the number of elements: 6

▪ Elements: 1, 2, 3, 4, 5, 6
ar

o Output:

▪ Even numbers in the array are: 2 4 6

m

▪ Odd numbers in the array are: 1 3 5

• Example 2 (All Even Numbers):

A

o Input: Enter the number of elements: 4

▪ Elements: 10, 20, 30, 40

o Output:

▪ Even numbers in the array are: 10 20 30 40

▪ Odd numbers in the array are:

 • Example 3 (All Odd Numbers):

o Input: Enter the number of elements: 5

▪ Elements: 11, 13, 15, 17, 19

o Output:

▪ Even numbers in the array are:

▪ Odd numbers in the array are: 11 13 15 17 19

ni
Edge Cases:

1. Empty Array: If the array is empty, no even or odd numbers exist, and the program

Pa
will print nothing.

2. Single Element Array: If the array has only one element, the program will print that
element in either the even or odd list based on its value.
ra
Time Complexity:
d
• The time complexity of this solution is O(n), where n is the number of elements in
the array. This is because the array is traversed once for even numbers and once for
en

odd numbers.
ar

7. Question: How do you compare two arrays in Java

without using any inbuilt methods?
m

Key Concept: To compare two arrays manually, we need to:

A

1. Check if the lengths of both arrays are the same.

2. If the lengths are different, the arrays are not equal.

3. If the lengths are the same, compare each element of one array with the
corresponding element in the other array.

4. If all elements match, the arrays are considered equal; otherwise, they are different.
Solution:

package array;

import java.util.Scanner;

public class CompareArraysWithoutInbuiltMethods {

public static void main(String[] args) {

ni
// Step 1: Accept input for the first array

Scanner scanner = new Scanner(System.in);

Pa
System.out.println("Enter the number of elements in the first array: ");

int n1 = scanner.nextInt(); // Size of the first array

ra
int[] arr1 = new int[n1]; // Create the first array

System.out.println("Enter " + n1 + " elements of the first array: ");

d
for (int i = 0; i < n1; i++) {
en

arr1[i] = scanner.nextInt(); // Input the elements into the first array

}
ar

// Step 2: Accept input for the second array

System.out.println("Enter the number of elements in the second array: ");

m

int n2 = scanner.nextInt(); // Size of the second array

A

int[] arr2 = new int[n2]; // Create the second array

System.out.println("Enter " + n2 + " elements of the second array: ");

for (int i = 0; i < n2; i++) {

arr2[i] = scanner.nextInt(); // Input the elements into the second array

}
// Step 3: Compare the arrays

boolean areEqual = true;

// Check if lengths are different

if (n1 != n2) {

areEqual = false;

} else {

ni
// Compare elements one by one

Pa
for (int i = 0; i < n1; i++) {

if (arr1[i] != arr2[i]) {

areEqual = false;
ra
break; // No need to compare further if a mismatch is found
d
}
en

}
ar

// Step 4: Output the result

if (areEqual) {
m

System.out.println("Both arrays are equal.");

A

} else {

System.out.println("Arrays are not equal.");

// Closing scanner to avoid memory leaks

scanner.close();
}

Explanation of Steps:

1. Input Handling: We take input for two arrays separately.

2. Length Comparison:

o If the lengths of the two arrays are not the same, the arrays are not equal.

ni
3. Element-by-Element Comparison:

Pa
o If the lengths are the same, we compare each corresponding element of the
two arrays.

o If all elements match, the arrays are equal.

ra
o If a mismatch is found at any position, we stop further comparison and
conclude that the arrays are not equal.
d
4. Output the Result: Based on the comparison, we print whether the arrays are equal
or not.
en

Input/Output Examples:

• Example 1:
ar

o Input:
m

▪ First array: 1, 2, 3, 4, 5

▪ Second array: 1, 2, 3, 4, 5
A

o Output: Both arrays are equal.

• Example 2 (Different Lengths):

o Input:

▪ First array: 1, 2, 3

▪ Second array: 1, 2, 3, 4
 o Output: Arrays are not equal.

• Example 3 (Same Length, Different Elements):

o Input:

▪ First array: 10, 20, 30

▪ Second array: 10, 25, 30

o Output: Arrays are not equal.

ni
Edge Cases:

1. Empty Arrays: If both arrays are empty, they are considered equal.

Pa
2. Single Element Arrays: If both arrays have only one element, they are equal if that
single element is the same. ra
Time Complexity:

• The time complexity of this solution is O(n), where n is the number of elements in
d
the arrays. This is because we compare each element once.

8. Question: How do you compare two arrays using

en

predefined methods in Java?

ar

Key Concept: Java provides several predefined methods to compare two arrays, including:

1. Arrays.equals(): This method compares two arrays for equality. It returns true if both
m

arrays have the same length and contain the same elements in the same order.

2. Arrays.deepEquals(): Used for comparing multidimensional arrays.

A

3. Arrays.compare(): Compares two arrays lexicographically.

4. Arrays.mismatch(): Returns the index of the first mismatch between two arrays.

In this solution, we will focus on using Arrays.equals() to compare two one-dimensional

arrays.
Solution: Using Arrays.equals():

package array;

import java.util.Arrays;

import java.util.Scanner;

public class CompareArraysWithPredefinedMethods {

ni
public static void main(String[] args) {

// Step 1: Accept input for the first array

Pa
Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements in the first array: ");

ra
int n1 = scanner.nextInt(); // Size of the first array

int[] arr1 = new int[n1]; // Create the first array

d
System.out.println("Enter " + n1 + " elements of the first array: ");
en

for (int i = 0; i < n1; i++) {

arr1[i] = scanner.nextInt(); // Input the elements into the first array

ar

// Step 2: Accept input for the second array

m

System.out.println("Enter the number of elements in the second array: ");

A

int n2 = scanner.nextInt(); // Size of the second array

int[] arr2 = new int[n2]; // Create the second array

System.out.println("Enter " + n2 + " elements of the second array: ");

for (int i = 0; i < n2; i++) {

arr2[i] = scanner.nextInt(); // Input the elements into the second array

}

// Step 3: Compare the arrays using Arrays.equals()

boolean areEqual = Arrays.equals(arr1, arr2);

// Step 4: Output the result

if (areEqual) {

System.out.println("Both arrays are equal.");

ni
} else {

Pa
System.out.println("Arrays are not equal.");

// Closing scanner to avoid memory leaks

ra
scanner.close();
d
}
en

Explanation of Steps:
ar

1. Input Handling: We take input for two arrays (first and second) from the user.

2. Using Arrays.equals() Method: This method is used to compare both arrays. It returns
m

true if:

o Both arrays have the same length.

A

o All corresponding elements in both arrays are equal.

3. Output the Result: Based on the result of the Arrays.equals() method, the program
prints whether the arrays are equal or not.
Input/Output Examples:

• Example 1:

o Input:

▪ First array: 1, 2, 3, 4, 5

▪ Second array: 1, 2, 3, 4, 5

o Output: Both arrays are equal.

ni
• Example 2 (Different Lengths):

o Input:

Pa
▪ First array: 1, 2, 3

▪ Second array: 1, 2, 3, 4

o Output: Arrays are not equal.

ra
• Example 3 (Same Length, Different Elements):
d
o Input:
en

▪ First array: 10, 20, 30

▪ Second array: 10, 25, 30

ar

o Output: Arrays are not equal.

o
m

Bonus: Using Arrays.mismatch() Method

A

The Arrays.mismatch() method returns the index of the first differing element between two
arrays. If no mismatch is found, it returns -1.

Here's how you can use it:

package array;

import java.util.Arrays;
import java.util.Scanner;

public class CompareArraysWithMismatch {

public static void main(String[] args) {

// Step 1: Accept input for the first array

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements in the first array: ");

ni
int n1 = scanner.nextInt(); // Size of the first array

Pa
int[] arr1 = new int[n1]; // Create the first array

System.out.println("Enter " + n1 + " elements of the first array: ");

for (int i = 0; i < n1; i++) {

ra
arr1[i] = scanner.nextInt(); // Input the elements into the first array
d
}
en

// Step 2: Accept input for the second array

System.out.println("Enter the number of elements in the second array: ");

ar

int n2 = scanner.nextInt(); // Size of the second array

int[] arr2 = new int[n2]; // Create the second array

m

System.out.println("Enter " + n2 + " elements of the second array: ");

A

for (int i = 0; i < n2; i++) {

arr2[i] = scanner.nextInt(); // Input the elements into the second array

// Step 3: Find the first mismatch index using Arrays.mismatch()

int mismatchIndex = Arrays.mismatch(arr1, arr2);

// Step 4: Output the result

if (mismatchIndex == -1) {

System.out.println("Both arrays are equal.");

} else {

System.out.println("Arrays differ at index: " + mismatchIndex);

ni
// Closing scanner to avoid memory leaks

Pa
scanner.close();

}
ra
Input/Output Examples:
d
• Example 1:
en

o Input:

▪ First array: 1, 2, 3, 4, 5
ar

▪ Second array: 1, 2, 3, 4, 5

o Output: Both arrays are equal.

m

• Example 2 (Mismatch at Index):

o Input:
A

▪ First array: 10, 20, 30

▪ Second array: 10, 25, 30

o Output: Arrays differ at index: 1

Time Complexity:

• Both Arrays.equals() and Arrays.mismatch() have a time complexity of O(n), where n

is the number of elements in the arrays. The methods compare each element one by
one.

Solution 3: Using Arrays.deepEquals() to Compare Arrays

ni
Key Concept:

• The Arrays.deepEquals() method is used to compare multi-dimensional arrays

Pa
(nested arrays), as it compares the content of each array and any sub-arrays
recursively.

• It returns true if both arrays are deeply equal.

ra
• This method is useful when comparing arrays that contain other arrays as elements.

When to Use:
d
• When comparing nested arrays (multi-dimensional arrays) or arrays of objects that
en

may contain arrays themselves.

Code Example for Arrays.deepEquals():

ar

package array;
m

import java.util.Arrays;

public class CompareArraysWithDeepEquals {

A

public static void main(String[] args) {

// Step 1: Define two 2D arrays

int[][] array1 = { {1, 2, 3}, {4, 5, 6} };

int[][] array2 = { {1, 2, 3}, {4, 5, 6} };

// Step 2: Compare the two arrays using Arrays.deepEquals()

boolean areEqual = Arrays.deepEquals(array1, array2);

// Step 3: Output the result

if (areEqual) {

System.out.println("Both arrays are equal.");

} else {

System.out.println("Arrays are not equal.");

ni
}

Pa
}

Explanation of Steps:
ra
1. Multi-Dimensional Arrays: The program defines two 2D arrays (array1 and array2).
d
2. Using Arrays.deepEquals(): This method compares the elements of the arrays deeply,
including any nested arrays.
en

3. Output: The result is printed depending on whether the arrays are deeply equal.

Input/Output Examples:
ar

• Example 1:
m

o Input: array1 = { {1, 2, 3}, {4, 5, 6} } and array2 = { {1, 2, 3}, {4, 5, 6} }

o Output: Both arrays are equal.

A

• Example 2 (Different Nested Arrays):

o Input: array1 = { {1, 2, 3}, {4, 5, 6} } and array2 = { {1, 2, 3}, {4, 0, 6} }

o Output: Arrays are not equal.

Solution 4: Using Arrays.compare() to Compare Arrays

Key Concept:

• The Arrays.compare() method compares two arrays lexicographically.

• Lexicographic comparison is like comparing strings: if two arrays are identical up to a

point, the first differing element determines which array is considered larger.

o It returns:

ni
▪ 0 if both arrays are lexicographically equal.

Pa
▪ A negative number if the first array is lexicographically smaller.

▪ A positive number if the first array is lexicographically larger.

When to Use:
ra
• When you need to compare arrays in a lexicographical order, especially for sorting
purposes.
d
Code Example for Arrays.compare():
en

package array;

import java.util.Arrays;
ar

public class CompareArraysLexicographically {

m

public static void main(String[] args) {

// Step 1: Define two arrays

A

int[] array1 = {1, 2, 3};

int[] array2 = {1, 2, 4};

// Step 2: Compare the arrays lexicographically using Arrays.compare()

int comparisonResult = Arrays.compare(array1, array2);

// Step 3: Output the result

if (comparisonResult == 0) {

System.out.println("Both arrays are lexicographically equal.");

} else if (comparisonResult < 0) {

System.out.println("The first array is lexicographically smaller.");

} else {

System.out.println("The first array is lexicographically larger.");

ni
}

Pa
}

Explanation of Steps:
ra
1. Array Declaration: The program defines two one-dimensional arrays (array1 and
array2).
d
2. Using Arrays.compare(): This method compares the arrays element by element,
en

starting from the first element.

3. Result Interpretation:
ar

o If the arrays are equal, it returns 0.

o If the first array is smaller, it returns a negative value.

m

o If the first array is larger, it returns a positive value.

A

Input/Output Examples:

• Example 1:

o Input: array1 = {1, 2, 3} and array2 = {1, 2, 4}

o Output: The first array is lexicographically smaller.

• Example 2:
 o Input: array1 = {10, 20, 30} and array2 = {10, 20, 30}

o Output: Both arrays are lexicographically equal.

• Example 3:

o Input: array1 = {5, 6, 7} and array2 = {5, 6, 5}

o Output: The first array is lexicographically larger.

ni
Summary of Solutions:

Pa
1. Arrays.equals(): Compares two one-dimensional arrays element by element for
equality.

2. Arrays.mismatch(): Returns the index of the first differing element or -1 if the arrays
are identical.
ra
3. Arrays.deepEquals(): Compares multi-dimensional arrays or arrays that contain
arrays.
d
4. Arrays.compare(): Compares arrays lexicographically and returns a value based on
en

whether the first array is smaller, larger, or equal.

These predefined methods provide different ways to compare arrays based on your specific
ar

needs: simple equality, lexicographical comparison, or deep comparison for nested arrays.
m

9. Question: How do you find the missing element in an

array in Java?
A

Key Concept:

In this problem, you are typically given an array containing n-1 elements, and these
elements are from a sequence of n consecutive numbers. One element is missing from the
sequence, and the task is to find that missing element.
There are several approaches to solve this problem, but a commonly used and efficient
solution involves calculating the expected sum of all numbers in the sequence and then
subtracting the actual sum of the array elements. The difference will give the missing
number.

Approach:

1. Sum Formula for Consecutive Numbers:

o The sum of the first n natural numbers is given by the formula:

ni
Sum=n×(n+1)2\text{Sum} = \frac{n \times (n+1)}{2}Sum=2n×(n+1)

2. Calculate the Sum of the Given Array:

Pa
o Iterate through the array and calculate the sum of its elements.

3. Find the Missing Element:

o
ra
Subtract the sum of the array elements from the expected sum of n
consecutive numbers. The result will be the missing element.
d
Solution:
en

package array;

import java.util.Scanner;
ar

public class FindMissingElement {

m

public static void main(String[] args) {

A

// Step 1: Accept input for the array size

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements (n-1) in the array: ");

int n = scanner.nextInt() + 1; // The array should have n-1 elements, but we want n for
sum calculation
int[] arr = new int[n - 1]; // Create an array of size n-1 (one element is missing)

System.out.println("Enter " + (n - 1) + " elements of the array: ");

for (int i = 0; i < n - 1; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

ni
// Step 2: Calculate the expected sum of the first n natural numbers

Pa
int expectedSum = n * (n + 1) / 2;

// Step 3: Calculate the sum of the array elements

int actualSum = 0;
ra
for (int i = 0; i < n - 1; i++) {
d
actualSum += arr[i];
en

}
ar

// Step 4: Find the missing element

int missingElement = expectedSum - actualSum;

m

// Step 5: Output the missing element

A

System.out.println("The missing element is: " + missingElement);

// Closing scanner to avoid memory leaks

scanner.close();

}
}

Explanation of Steps:

1. Input Handling: The program first takes input for the size of the array (n-1 elements).
The number n is calculated by adding 1 to the size of the array.

2. Expected Sum Calculation: We calculate the expected sum of the first n natural
numbers using the formula n * (n + 1) / 2.

ni
3. Actual Sum Calculation: The program iterates through the array and calculates the
sum of the given elements.

Pa
4. Finding the Missing Element: The missing element is found by subtracting the actual
sum from the expected sum.

5. Output: The missing element is printed.

ra
Input/Output Examples:

• Example 1:
d
o Input: Enter 4 elements (from numbers 1 to 5): 1, 2, 3, 5
en

o Output: The missing element is: 4

• Example 2:
ar

o Input: Enter 9 elements (from numbers 1 to 10): 1, 2, 3, 4, 6, 7, 8, 9, 10

m

o Output: The missing element is: 5

Edge Cases:
A

1. Small Arrays: For arrays with only two elements (from numbers 1 to 3), the solution
should work correctly.

2. Missing First or Last Element: The solution works even if the missing number is the
first or last in the sequence.
Time Complexity:

• The time complexity of this solution is O(n), where n is the number of elements in
the array. This is because we calculate the sum of the elements by iterating through
the array once.

10. Question: How do you find the maximum and

minimum elements in a given array in Java?

ni
Key Concept:

Pa
To find both the maximum and minimum elements in an array, we can iterate through the
array once and keep track of both the maximum and minimum values as we compare each
element. This approach ensures an optimal time complexity of O(n) since we traverse the
array only once.
ra
Solution:
d
package array;
en

import java.util.Scanner;

public class FindMaxMinInArray {

ar

public static void main(String[] args) {

m

// Step 1: Accept input for the array

Scanner scanner = new Scanner(System.in);

A

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

if (n <= 0) {

System.out.println("Array must have at least one element.");

return;
}

int[] arr = new int[n]; // Create an array of the given size

System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

ni
// Step 2: Initialize variables for max and min with the first element

Pa
int max = arr[0];

int min = arr[0];

// Step 3: Traverse the array to find max and min

ra
for (int i = 1; i < n; i++) {
d
if (arr[i] > max) {
en

max = arr[i]; // Update max if current element is greater

}
ar

if (arr[i] < min) {

min = arr[i]; // Update min if current element is smaller

m

}
A

// Step 4: Output the maximum and minimum values

System.out.println("Maximum element in the array is: " + max);

System.out.println("Minimum element in the array is: " + min);

// Closing scanner to avoid memory leaks

scanner.close();

Explanation of Steps:

1. Input Handling: The program takes input for the array size and the array elements. It

ni
also checks if the array has at least one element (to avoid errors).

2. Initialization: We initialize two variables max and min with the first element of the

Pa
array.

3. Array Traversal: The program iterates through the array starting from the second
element:
ra
o If the current element is greater than max, we update max.

o If the current element is smaller than min, we update min.

d
4. Output: After the loop, the maximum and minimum values are printed.
en

Input/Output Examples:
ar

• Example 1:

o Input: Enter the number of elements: 5

m

▪ Elements: 3, 1, 4, 1, 5

o Output:
A

▪ Maximum element in the array is: 5

▪ Minimum element in the array is: 1

• Example 2:

o Input: Enter the number of elements: 6

▪ Elements: 10, -2, 34, 0, 7, -15

 o Output:

▪ Maximum element in the array is: 34

▪ Minimum element in the array is: -15

• Example 3 (Single Element Array):

o Input: Enter the number of elements: 1

▪ Element: 42

ni
o Output:

▪ Maximum element in the array is: 42

Pa
▪ Minimum element in the array is: 42

Edge Cases:
ra
1. Single Element Array: If the array has only one element, both the maximum and
minimum will be that element.
d
2. Negative Numbers: The solution works for arrays that contain negative numbers as
en

well.

Time Complexity:
ar

• The time complexity is O(n) because we traverse the array only once, where n is the
number of elements in the array.
m

11. Question: How do you search for a given element in

A

an array in Java?

Key Concept:

To search for an element in an array, we can use linear search, which is the simplest
method. In linear search, we traverse the array element by element, comparing each
element with the target value. If the target value is found, we return the index at which it is
located; otherwise, we return that the element is not found.
Solution:

package array;

import java.util.Scanner;

public class SearchElementInArray {

public static void main(String[] args) {

ni
// Step 1: Accept input for the array

Scanner scanner = new Scanner(System.in);

Pa
System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

ra
int[] arr = new int[n]; // Create an array of the given size

System.out.println("Enter " + n + " elements of the array: ");

d
for (int i = 0; i < n; i++) {
en

arr[i] = scanner.nextInt(); // Input the elements into the array

}
ar

// Step 2: Accept the element to search for

System.out.println("Enter the element to search for: ");

m

int target = scanner.nextInt(); // Input the target element

A

// Step 3: Perform linear search

int index = -1; // Initialize with -1 (element not found by default)

for (int i = 0; i < n; i++) {

if (arr[i] == target) {

index = i; // Update index if the target is found

break; // No need to search further

// Step 4: Output the result

if (index != -1) {

System.out.println("Element " + target + " found at index: " + index);

ni
} else {

Pa
System.out.println("Element " + target + " not found in the array.");

// Closing scanner to avoid memory leaks

ra
scanner.close();
d
}
en

Explanation of Steps:
ar

1. Input Handling: The program first takes input for the array size and its elements.

2. Target Input: The program prompts the user to enter the element they want to
m

search for in the array.

3. Linear Search:
A

o We initialize an index variable to -1, which indicates that the element is not
found.

o We traverse the array using a for loop and compare each element with the
target.

o If the target element is found, we update the index to the current position
and exit the loop using break.
 4. Result Output: If the element is found, we print its index; otherwise, we print a
message indicating that the element is not found.

Input/Output Examples:

• Example 1:

o Input:

▪ Enter the number of elements: 5

ni
▪ Elements: 10, 20, 30, 40, 50

▪ Target: 30

Pa
o Output: Element 30 found at index: 2

• Example 2: ra
o Input:

▪ Enter the number of elements: 4

d
▪ Elements: 5, 10, 15, 20
en

▪ Target: 25

o Output: Element 25 not found in the array.

ar

• Example 3 (First Element Match):

o Input:
m

▪ Enter the number of elements: 3

A

▪ Elements: 3, 6, 9

▪ Target: 3

o Output: Element 3 found at index: 0

Edge Cases:

1. Empty Array: If the array has no elements, the program should immediately print
that the element is not found.
 2. Target Not Present: The program correctly handles the case where the target
element is not present in the array.

3. Single Element Array: If the array has only one element, the search will either find
the target or return that it's not found.

Time Complexity:

• The time complexity of linear search is O(n), where n is the number of elements in
the array, because we may need to check every element in the worst case.

ni
Pa
12. Question: How do you print the elements of an array in
Java?

Key Concept:
ra
To print the elements of an array in Java, we can either use a loop to iterate through the
array and print each element, or use the Arrays.toString() method for single-dimensional
d
arrays or Arrays.deepToString() for multi-dimensional arrays.
en

Solution 1: Using a Loop to Print an Array

package array;
ar

import java.util.Scanner;
m

public class PrintArrayUsingLoop {

public static void main(String[] args) {

A

// Step 1: Accept input for the array

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

int[] arr = new int[n]; // Create an array of the given size

System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

// Step 2: Print the elements of the array

System.out.println("The elements in the array are: ");

ni
for (int i = 0; i < n; i++) {

Pa
System.out.print(arr[i] + " "); // Print each element followed by a space

// Close the scanner to avoid memory leaks

ra
scanner.close();
d
}
en

Explanation of Steps:
ar

1. Input Handling: The program takes input for the array size and its elements.

2. Using a Loop: A for loop is used to iterate through the array and print each element,
m

followed by a space.

Input/Output Examples:
A

• Example 1:

o Input:

▪ Enter the number of elements: 5

▪ Elements: 1, 2, 3, 4, 5

o Output: The elements in the array are: 1 2 3 4 5

 • Example 2:

o Input:

▪ Enter the number of elements: 3

▪ Elements: 10, 20, 30

o Output: The elements in the array are: 10 20 30

ni
Solution 2: Using Arrays.toString() Method

Pa
If you want a more concise way to print the array elements, Java provides the
Arrays.toString() method that prints the array in a readable format.

package array;
ra
import java.util.Arrays;

import java.util.Scanner;
d
public class PrintArrayUsingToString {
en

public static void main(String[] args) {

// Step 1: Accept input for the array

ar

Scanner scanner = new Scanner(System.in);

m

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

A

int[] arr = new int[n]; // Create an array of the given size

System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

}// Step 2: Print the array using Arrays.toString()

System.out.println("The elements in the array are: " + Arrays.toString(arr));

// Close the scanner to avoid memory leaks

scanner.close();

Explanation:

ni
• Arrays.toString(arr) converts the array into a string format that looks like [1, 2, 3, 4, 5]
and prints it all at once.

Pa
Input/Output Examples:

• Example 1:

o Input:
ra
▪ Enter the number of elements: 5
d
▪ Elements: 1, 2, 3, 4, 5
en

o Output: The elements in the array are: [1, 2, 3, 4, 5]

• Example 2:
ar

o Input:

▪ Enter the number of elements: 4

m

▪ Elements: 10, 20, 30, 40

A

o Output: The elements in the array are: [10, 20, 30, 40]
Solution 3: Printing a Multi-Dimensional Array Using Arrays.deepToString()

If you are working with multi-dimensional arrays, you can use the Arrays.deepToString()
method to print the array.

package array;

import java.util.Arrays;

public class PrintMultiDimensionalArray {

ni
public static void main(String[] args) {

Pa
// Define a 2D array

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

// Print the 2D array using Arrays.deepToString()

ra
System.out.println("The elements in the 2D array are: ");
d
System.out.println(Arrays.deepToString(arr));
en

}
ar

Explanation:

• Arrays.deepToString(arr) converts multi-dimensional arrays into a string format. This

m

method recursively converts each sub-array into a string and outputs them.

Input/Output Example:
A

• Output: The elements in the 2D array are: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Time Complexity:

• The time complexity of all the solutions is O(n), where n is the number of elements in
the array, as we need to iterate through the array to print its contents.
13. Question: How do you sort the elements in an array
using built-in functions in Java?

Key Concept:

To sort an array in Java, you can use the Arrays.sort() method from the java.util.Arrays class.
This method sorts the array in ascending order by default. If you need to sort the array in
descending order, you can combine Arrays.sort() with a custom comparator or use
Collections.reverseOrder() for certain types like Integer[].

ni
Solution 1: Sorting in Ascending Order Using Arrays.sort()

Pa
Steps:

1. Import the java.util.Arrays package.

2. Use Arrays.sort() to sort the array in ascending order.

ra
Code Example for Ascending Order:
d
package array;
en

import java.util.Arrays;

import java.util.Scanner;
ar

public class SortArrayAscending {

public static void main(String[] args) {

m

// Step 1: Accept input for the array

A

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

int[] arr = new int[n]; // Create an array of the given size

System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

// Step 2: Sort the array in ascending order

Arrays.sort(arr);

// Step 3: Print the sorted array

ni
System.out.println("The array sorted in ascending order is: " +
Arrays.toString(arr));

Pa
// Close the scanner to avoid memory leaks

scanner.close();

}
ra
}
d
Explanation:
en

• Arrays.sort(arr) sorts the elements of the array in ascending order.

• Arrays.toString(arr) is used to print the sorted array.

ar

Input/Output Example:
m

• Input:

o Enter the number of elements: 5

A

o Elements: 5, 1, 3, 2, 4

• Output:

o The array sorted in ascending order is: [1, 2, 3, 4, 5]

Solution 2: Sorting in Descending Order Using Arrays.sort() with Collections.reverseOrder()

Steps:

1. Convert the array to an Integer[] (since Collections.reverseOrder() works only with

object arrays, not primitive arrays).

2. Use Arrays.sort() with Collections.reverseOrder() to sort the array in descending

order.

Code Example for Descending Order:

ni
package array;

Pa
import java.util.Arrays;

import java.util.Collections; ra
import java.util.Scanner;

public class SortArrayDescending {

d
public static void main(String[] args) {
en

// Step 1: Accept input for the array

Scanner scanner = new Scanner(System.in);

ar

System.out.println("Enter the number of elements in the array: ");

m

int n = scanner.nextInt(); // Take input for the size of the array

Integer[] arr = new Integer[n]; // Create an Integer array of the given size (non-
A

primitive)

System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

}
// Step 2: Sort the array in descending order

Arrays.sort(arr, Collections.reverseOrder());

// Step 3: Print the sorted array

System.out.println("The array sorted in descending order is: " +

Arrays.toString(arr));

// Close the scanner to avoid memory leaks

ni
scanner.close();

Pa
}

Explanation:

•
ra
We use Integer[] instead of int[] because Collections.reverseOrder() requires an
object array.
d
• Arrays.sort(arr, Collections.reverseOrder()) sorts the array in descending order.
en

Input/Output Example:

• Input:
ar

o Enter the number of elements: 5

o Elements: 5, 1, 3, 2, 4
m

• Output:
A

o The array sorted in descending order is: [5, 4, 3, 2, 1]

Solution 3: Sorting Multi-Dimensional Arrays Using Arrays.sort()

You can also sort individual rows in a 2D array.

Code Example for Sorting Rows in a 2D Array:

package array;

import java.util.Arrays;

public class SortMultiDimensionalArray {

ni
public static void main(String[] args) {

Pa
// Define a 2D array

int[][] arr = {

{3, 2, 1},
ra
{6, 5, 4},
d
{9, 8, 7}
en

};

// Step 1: Sort each row of the 2D array

ar

for (int i = 0; i < arr.length; i++) {

Arrays.sort(arr[i]);
m

}
A

// Step 2: Print the sorted 2D array

System.out.println("The 2D array with sorted rows is: ");

for (int[] row : arr) {

System.out.println(Arrays.toString(row));

}
}

Explanation:

• We sort each row individually using Arrays.sort().

Input/Output Example:

• Output:

ni
• The 2D array with sorted rows is:

Pa
[1, 2, 3]

[4, 5, 6] ra
[7, 8, 9]

Time Complexity:
d
• The time complexity of Arrays.sort() is O(n log n) where n is the number of elements
en

in the array. This is due to the Timsort algorithm used internally, which is highly
efficient for sorting.
ar
m
A
14. Question: How do you reverse an array in Java
using Java Collections?

Key Concept:

In Java, you can reverse an array using the Collections.reverse() method. However, since
Collections.reverse() works only with Lists, you'll need to first convert the array into a List,
perform the reversal, and if needed, convert the list back to an array.

ni
Steps:

Pa
1. Convert the array to a List using Arrays.asList().
2. Use Collections.reverse() to reverse the List.
3. (Optional) Convert the List back to an array if required.
ra
Solution:
d
package array;
en

import java.util.Arrays;

import java.util.Collections;
ar

import java.util.List;

import java.util.Scanner;
m

public class ReverseArrayUsingCollections {

A

public static void main(String[] args) {

// Step 1: Accept input for the array

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

Integer[] arr = new Integer[n]; // Create an Integer array of the given size (for
Collections.reverse)

System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

ni
// Step 2: Convert the array to a List

List<Integer> list = Arrays.asList(arr);

Pa
// Step 3: Reverse the list using Collections.reverse()

Collections.reverse(list);
ra
// Step 4: Print the reversed array (which is now a reversed list)

System.out.println("The reversed array is: " + list);

d
// Close the scanner to avoid memory leaks
en

scanner.close();

}
ar

}
m

Explanation of Steps:

1. Input Handling: The program first takes input for the array size and elements.
A

2. Convert to List: The array is converted into a List using Arrays.asList().

3. Reversing the List: The Collections.reverse() method is used to reverse the List.
4. Output: The reversed list is printed.
Input/Output Example:

• Input:
o Enter the number of elements: 5
o Elements: 1, 2, 3, 4, 5
• Output:
o The reversed array is: [5, 4, 3, 2, 1]

Optional: Convert the Reversed List Back to an Array

ni
If you need the reversed list back as an array, you can convert it using the toArray() method.

Pa
Code Example:

package array; ra
import java.util.Arrays;

import java.util.Collections;
d
import java.util.List;
en

import java.util.Scanner;

public class ReverseArrayUsingCollections {

ar

public static void main(String[] args) {

m

// Step 1: Accept input for the array

Scanner scanner = new Scanner(System.in);

A

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Take input for the size of the array

Integer[] arr = new Integer[n]; // Create an Integer array of the given size (for
Collections.reverse)

System.out.println("Enter " + n + " elements of the array: ");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input the elements into the array

// Step 2: Convert the array to a List

List<Integer> list = Arrays.asList(arr);

// Step 3: Reverse the list using Collections.reverse()

ni
Collections.reverse(list);

Pa
// Step 4: Convert the List back to an array

arr = list.toArray(new Integer[0]); // Convert the reversed list back to array

// Step 5: Print the reversed array

ra
System.out.println("The reversed array is: " + Arrays.toString(arr));
d
// Close the scanner to avoid memory leaks
en

scanner.close();

}
ar

Explanation of Additional Step:

m

• Converting Back to Array: After reversing the list, we convert the List back into an
A

Integer[] using the toArray() method.

Input/Output Example:

• Input:
o Enter the number of elements: 5
o Elements: 1, 2, 3, 4, 5
o
 • Output:
o The reversed array is: [5, 4, 3, 2, 1]

Time Complexity:

• The time complexity of Collections.reverse() is O(n), where n is the number of

elements in the list, as it performs an in-place reversal by swapping elements.

15. Question: How do you receive input from the user and

ni
save it into an array in Java?

Pa
Key Concept:

In Java, you can use the Scanner class to receive input from the user. For storing multiple
inputs into an array, you can:
ra
1. Create an array with a specified size.
2. Use a loop to repeatedly prompt the user for input and store each value in the array.
d
en

Solution:

package array;
ar

import java.util.Scanner;

public class SaveInputToArray {

m

public static void main(String[] args) {

A

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Prompt the user to enter the number of elements for the array

System.out.println("Enter the number of elements you want to store in the array:

");
int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Loop through to get 'n' inputs from the user and store them in the
array

System.out.println("Enter " + n + " elements:");

ni
for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Receive input and store in array

Pa
}

// Step 5: Print the array to verify the inputs

ra
System.out.println("You entered the following elements: ");

for (int i = 0; i < n; i++) {

d
System.out.print(arr[i] + " "); // Print each element
en

// Close the scanner to avoid memory leaks

ar

scanner.close();
m

}
A

Explanation of Steps:

1. Step 1: We create a Scanner object to receive input from the user.

2. Step 2: We prompt the user to input the number of elements they want to store in
the array, which determines the size of the array.
3. Step 3: We create an array of size n based on the user's input.
 4. Step 4: We use a loop to prompt the user to input each element, storing each value
into the array.
5. Step 5: After all inputs are stored, the program prints the array elements to verify
the inputs.

Input/Output Example:

• Input:
o Enter the number of elements you want to store in the array: 5

ni
o Enter 5 elements: 10 20 30 40 50
• Output:

Pa
o You entered the following elements: 10 20 30 40 50

Edge Cases: ra
1. Empty Array: If the user enters 0 for the number of elements, no input is stored in
the array.
d
2. Non-integer Input: The program will throw an error if non-integer input is provided,
as it expects integer input for both the size and elements.
en

Time Complexity:
ar

• The time complexity for inputting and printing the array is O(n), where n is the
number of elements.
m
A
16. Question: How do you reverse the elements of an array
in Java?

Key Concept:

Reversing an array means rearranging its elements so that the first element becomes the
last, the second element becomes the second-to-last, and so on. This can be done by
swapping elements from the start and end, moving towards the middle.

ni
Solution (Reversing the Array Manually by Swapping:

Pa
package array;

import java.util.Scanner;

public class ReverseArraySimplified {

ra
public static void main(String[] args) {
d
// Step 1: Create a Scanner object to receive input
en

Scanner scanner = new Scanner(System.in);

// Step 2: Prompt the user to enter the number of elements in the array
ar

System.out.println("Enter the number of elements you want to store in the array:

");
m

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

A

int[] arr = new int[n];

// Step 4: Loop through to get 'n' inputs from the user and store them in the
array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Receive input and store in array

// Step 5: Reverse the array using a for loop

for (int start = 0, end = n - 1; start < end; start++, end--) {

// Swap elements at the start and end

int temp = arr[start];

ni
arr[start] = arr[end];

Pa
arr[end] = temp;

// Step 6: Print the reversed array

ra
System.out.println("The reversed array is: ");
d
for (int i = 0; i < n; i++) {
en

System.out.print(arr[i] + " ");

}
ar

// Close the scanner to avoid memory leaks

scanner.close();
m

}
A

Explanation:

• Combining Increment/Decrement in the Loop:

o The for loop now handles both the initialization (start = 0, end = n - 1), the
condition (start < end), and the update (start++ and end--) in a single
structure. This makes the loop more concise and easier to read.
Input/Output Example:

• Input:

o Enter the number of elements you want to store in the array: 5

o Enter 5 elements: 1 2 3 4 5

• Output:

o The reversed array is: 5 4 3 2 1

ni
Edge Cases:

Pa
1. Single Element Array: If the array contains only one element, reversing it will result in
the same array. ra
2. Empty Array: If the array is empty (size 0), the program will print nothing as there are
no elements to reverse.
d
Time Complexity:
en

• The time complexity for reversing the array is O(n), where n is the number of
elements in the array. This is because we swap elements only once, and we iterate
over half the array.
ar
m

17. Question: How do you find the number of elements in a

given array in Java?
A

Key Concept:

In Java, the size of an array (i.e., the number of elements in the array) can be easily found
using the array's built-in property length. This property returns the total number of elements
in the array, which is useful when you need to iterate through or access the size of the array.
Solution:

package array;

import java.util.Scanner;

public class FindArraySize {

public static void main(String[] args) {

ni
// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

Pa
// Step 2: Prompt the user to enter the number of elements in the array

System.out.println("Enter the number of elements you want to store in the array:

");
ra
int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

d
int[] arr = new int[n];
en

// Step 4: Loop through to get 'n' inputs from the user and store them in the
array
ar

System.out.println("Enter " + n + " elements:");

m

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Receive input and store in array

A

// Step 5: Use the length property to find the number of elements

int numberOfElements = arr.length;

// Step 6: Print the number of elements in the array

System.out.println("The number of elements in the array is: " + numberOfElements);

// Close the scanner to avoid memory leaks

scanner.close();

Explanation of Steps:

1. Input Handling: The user is prompted to enter the size of the array and its elements.

ni
2. Array Length: The number of elements in the array is accessed using the arr.length
property, which returns the total number of elements stored in the array.

Pa
3. Output: The number of elements is printed to the console.

Input/Output Example:

• Input:
ra
o Enter the number of elements you want to store in the array: 5
d
o Enter 5 elements: 10, 20, 30, 40, 50
en

• Output:

o The number of elements in the array is: 5

ar

Key Points:
m

1. arr.length Property: This property gives you the total number of elements in the
A

array. It's a simple and efficient way to get the size of an array in Java.

2. Time Complexity: Accessing the length property is done in constant time O(1).
18. Question: How do you perform a right rotation of an
array by n positions in Java?

Key Concept:

In a right rotation of an array, elements are shifted to the right by a specified number of
positions. The elements that are shifted beyond the end of the array wrap around to the
beginning. For example, rotating the array [1, 2, 3, 4, 5] by 2 positions would result in [4, 5,
1, 2, 3].

ni
Approach:

Pa
1. Modular Arithmetic: Use modulo (%) to calculate the effective number of rotations
since rotating the array by its length results in the same array. Therefore, rotating by
n is equivalent to rotating by n % array.length.
ra
2. Reversing Parts of the Array: You can achieve the rotation in an optimal way by using
the reversal algorithm:
d
o Reverse the whole array.
en

o Reverse the first k elements.

o Reverse the remaining elements.

ar

Solution: Right Rotate an Array by n Positions

package array;
m

import java.util.Scanner;
A

public class RightRotateArray {

// Helper function to reverse part of the array

public static void reverse(int[] arr, int start, int end) {

while (start < end) {

int temp = arr[start];

arr[start] = arr[end];

arr[end] = temp;

start++;

end--;

ni
// Function to right rotate the array by n positions

Pa
public static void rightRotate(int[] arr, int n) {

int length = arr.length;

// If the array is empty or there's no need to rotate, return

ra
if (length == 0 || n <= 0) {
d
return;
en

// Step 1: Normalize the number of rotations (in case n > length)

ar

n = n % length;

// Step 2: Reverse the whole array

m

reverse(arr, 0, length - 1);

A

// Step 3: Reverse the first n elements

reverse(arr, 0, n - 1);

// Step 4: Reverse the remaining elements

reverse(arr, n, length - 1);

}
public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Prompt the user to enter the number of elements in the array

System.out.println("Enter the number of elements you want to store in the array:

");

ni
int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

Pa
int[] arr = new int[n];

// Step 4: Loop through to get 'n' inputs from the user and store them in the
array
ra
System.out.println("Enter " + n + " elements:");
d
for (int i = 0; i < n; i++) {
en

arr[i] = scanner.nextInt(); // Receive input and store in array

}
ar

// Step 5: Ask the user for the number of rotations

System.out.println("Enter the number of positions to rotate: ");

m

int rotations = scanner.nextInt();

A

// Step 6: Right rotate the array by the given number of positions

rightRotate(arr, rotations);

// Step 7: Print the rotated array

System.out.println("The array after right rotation is: ");

for (int i = 0; i < arr.length; i++) {

System.out.print(arr[i] + " ");

// Close the scanner to avoid memory leaks

scanner.close();

ni
Explanation of Steps:

Pa
1. Reverse Helper Function: The reverse() function is used to reverse a portion of the
array between two indices (start and end).

2. Right Rotate Function:

ra
o The rightRotate() function first normalizes the number of rotations (n %
length).
d
o It then performs the rotation using three reverse operations:
en

▪ Reverse the entire array.

▪ Reverse the first n elements.

ar

▪ Reverse the remaining elements.

3. Main Program: The program prompts the user for input, rotates the array by the
m

specified number of positions, and prints the rotated array.

Input/Output Example:
A

• Input:

o Enter the number of elements you want to store in the array: 5

o Enter 5 elements: 1 2 3 4 5

o Enter the number of positions to rotate: 2

o
 • Output:

o The array after right rotation is: 4 5 1 2 3

Edge Cases:

1. No Rotation Needed: If n = 0 or n % array.length = 0, the array remains unchanged.

2. n Larger than Array Length: The modulo operation (n % length) handles cases where
n is greater than the length of the array.

ni
3. Empty Array: If the array is empty, the program should handle it without errors.

Time Complexity:

Pa
• The time complexity of this approach is O(n), where n is the number of elements in
the array. This is because each element is swapped only a constant number of times
during the reversal operations.
ra
19. Question: How do you perform a left rotation of an
d
array by n positions in Java?
en

Key Concept:
ar

In a left rotation of an array, elements are shifted to the left by a specified number of
positions. The elements that are shifted beyond the start of the array wrap around to the
end. For example, rotating the array [1, 2, 3, 4, 5] by 2 positions to the left would result in [3,
m

4, 5, 1, 2].

Approach:
A

1. Modular Arithmetic: Use modulo (%) to calculate the effective number of rotations,
because rotating by the length of the array brings the array back to its original state.
Therefore, rotating by n is equivalent to rotating by n % array.length.

2. Reversing Parts of the Array: The same reversal algorithm used for right rotation can
be used for left rotation, but with different parts of the array:
 o Reverse the first n elements.

o Reverse the remaining elements.

o Reverse the whole array.

package array;

import java.util.Scanner;

public class LeftRotateArray {

ni
// Helper function to reverse part of the array

Pa
public static void reverse(int[] arr, int start, int end) {

while (start < end) {

int temp = arr[start];

ra
arr[start] = arr[end];
d
arr[end] = temp;
en

start++;

end--;
ar

}
m

// Function to left rotate the array by n positions

A

public static void leftRotate(int[] arr, int n) {

int length = arr.length;

// If the array is empty or there's no need to rotate, return

if (length == 0 || n <= 0) {

return;
}

// Step 1: Normalize the number of rotations (in case n > length)

n = n % length;

// Step 2: Reverse the first n elements

reverse(arr, 0, n - 1);

// Step 3: Reverse the remaining elements

ni
reverse(arr, n, length - 1);

Pa
// Step 4: Reverse the whole array

reverse(arr, 0, length - 1);

}
ra
public static void main(String[] args) {
d
// Step 1: Create a Scanner object to receive input
en

Scanner scanner = new Scanner(System.in);

// Step 2: Prompt the user to enter the number of elements in the array
ar

System.out.println("Enter the number of elements you want to store in the array:

");
m

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

A

int[] arr = new int[n];

// Step 4: Loop through to get 'n' inputs from the user and store them in the
array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Receive input and store in array

// Step 5: Ask the user for the number of rotations

System.out.println("Enter the number of positions to rotate: ");

int rotations = scanner.nextInt();

// Step 6: Left rotate the array by the given number of positions

ni
leftRotate(arr, rotations);

Pa
// Step 7: Print the rotated array

System.out.println("The array after left rotation is: ");

for (int i = 0; i < arr.length; i++) {

ra
System.out.print(arr[i] + " ");
d
}
en

// Close the scanner to avoid memory leaks

scanner.close();
ar

}
m

Explanation of Steps:
A

1. Reverse Helper Function: The reverse() function is used to reverse a portion of the
array between two indices (start and end).

2. Left Rotate Function:

o The leftRotate() function first normalizes the number of rotations (n %

length).

o It then performs the rotation using three reverse operations:

 ▪ Reverse the first n elements.

▪ Reverse the remaining elements.

▪ Reverse the entire array.

3. Main Program: The program prompts the user for input, rotates the array by the
specified number of positions, and prints the rotated array.

Input/Output Example:

ni
• Input:

o Enter the number of elements you want to store in the array: 5

Pa
o Enter 5 elements: 1 2 3 4 5

o Enter the number of positions to rotate: 2

ra
• Output:

o The array after left rotation is: 3 4 5 1 2

d
Edge Cases:
en

1. No Rotation Needed: If n = 0 or n % array.length = 0, the array remains unchanged.

2. n Larger than Array Length: The modulo operation (n % length) handles cases where
ar

n is greater than the length of the array.

3. Empty Array: If the array is empty, the program should handle it without errors.
m

Time Complexity:

• The time complexity of this approach is O(n), where n is the number of elements in
A

the array. This is because each element is swapped only a constant number of times
during the reversal operations.
20. Question: How do you swap the first and last elements
of an array in Java?

Key Concept:

Swapping the first and last elements of an array involves:

1. Storing the first element in a temporary variable.

2. Assigning the last element to the first position.

ni
3. Assigning the value stored in the temporary variable to the last position.

Pa
Solution: Swapping First and Last Elements of an Array

package array;

import java.util.Scanner;
ra
public class SwapFirstLast {

public static void main(String[] args) {

d
// Step 1: Create a Scanner object to receive input
en

Scanner scanner = new Scanner(System.in);

ar

// Step 2: Prompt the user to enter the number of elements in the array

System.out.println("Enter the number of elements you want to store in the array:

m

");

int n = scanner.nextInt(); // Size of the array

A

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Loop through to get 'n' inputs from the user and store them in the
array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Receive input and store in array

// Step 5: Swap the first and last elements if the array has more than 1 element

if (n > 1) {

int temp = arr[0]; // Store the first element in a temp variable

ni
arr[0] = arr[n - 1]; // Assign the last element to the first position

Pa
arr[n - 1] = temp; // Assign the temp (first element) to the last position

// Step 6: Print the modified array

ra
System.out.println("The array after swapping first and last elements is: ");
d
for (int i = 0; i < n; i++) {
en

System.out.print(arr[i] + " ");

}
ar

// Close the scanner to avoid memory leaks

scanner.close();
m

}
A

Explanation of Steps:

1. Input Handling: The program takes input for the array size and its elements.

2. Swapping Logic:

o A temporary variable (temp) is used to store the first element.

 o The last element is assigned to the first position.

o The value stored in temp (initially the first element) is assigned to the last
position.

3. Output: The modified array is printed after swapping the first and last elements.

Input/Output Example:

• Input:

ni
o Enter the number of elements you want to store in the array: 5

o Enter 5 elements: 10 20 30 40 50

Pa
• Output:

o The array after swapping first and last elements is: 50 20 30 40 10

ra
Edge Cases:

1. Single Element Array: If the array contains only one element, the array remains
d
unchanged, as there's nothing to swap.
en

2. Empty Array: If the array is empty (n = 0), no swap is performed, and the program
handles this without errors.
ar

Time Complexity:
m

• The time complexity of this operation is O(1) because swapping the first and last
elements involves only constant-time operations (accessing and assigning two array
elements).
A
Solution: Swap First and Last Elements Without Using a Third Variable

package array;

import java.util.Scanner;

public class SwapFirstLastWithoutTemp {

public static void main(String[] args) {

ni
// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

Pa
// Step 2: Prompt the user to enter the number of elements in the array

System.out.println("Enter the number of elements you want to store in the array:

");
ra
int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

d
int[] arr = new int[n];
en

// Step 4: Loop through to get 'n' inputs from the user and store them in the
array
ar

System.out.println("Enter " + n + " elements:");

m

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Receive input and store in array

A

// Step 5: Swap the first and last elements without using a third variable (if
array has more than 1 element)

if (n > 1) {

arr[0] = arr[0] + arr[n - 1]; // Step 1: arr[0] becomes the sum of arr[0] and
arr[n - 1]
arr[n - 1] = arr[0] - arr[n - 1]; // Step 2: arr[n - 1] becomes the original
arr[0]

arr[0] = arr[0] - arr[n - 1]; // Step 3: arr[0] becomes the original arr[n - 1]

// Step 6: Print the modified array

System.out.println("The array after swapping first and last elements is: ");

ni
for (int i = 0; i < n; i++) {

System.out.print(arr[i] + " ");

Pa
}

// Close the scanner to avoid memory leaks

scanner.close();
ra
}
d
}
en

Explanation:
ar

1. No Temporary Variable:

o Instead of using a temporary variable, the swapping is done using arithmetic

(addition and subtraction):
m

▪ arr[0] = arr[0] + arr[n - 1]; — The first element (arr[0]) becomes the
A

sum of the first and last elements.

▪ arr[n - 1] = arr[0] - arr[n - 1]; — The last element (arr[n - 1]) becomes
the original first element by subtracting the new arr[0] value (sum)
from the last element.

▪ arr[0] = arr[0] - arr[n - 1]; — The first element (arr[0]) becomes the
original last element by subtracting the new arr[n - 1] value from the
sum.
 2. No Extra Space: This approach avoids using a third variable, as the swap is performed
directly within the array using basic arithmetic.

Input/Output Example:

• Input:

o Enter the number of elements you want to store in the array: 5

o Enter 5 elements: 10 20 30 40 50

ni
• Output:

o The array after swapping first and last elements is: 50 20 30 40 10

Pa
Edge Cases:

1. Single Element Array: If the array contains only one element, the array remains
unchanged.
ra
2. Empty Array: If the array is empty, no operations are performed.
d
Time Complexity:
en

• The time complexity remains O(1) since only constant-time arithmetic operations are
performed to swap the elements.
ar

21. Question: How do you multiply the corresponding

elements of two arrays in Java?
m

Key Concept:
A

To multiply the corresponding elements of two arrays, you need to:

1. Ensure that both arrays are of the same size.

2. Loop through the arrays and multiply the elements at the same index in both arrays.

3. Store the results in a new array.

Solution:

package array;

import java.util.Scanner;

public class MultiplyArrays {

public static void main(String[] args) {

ni
// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

Pa
// Step 2: Prompt the user to enter the size of the arrays

System.out.println("Enter the number of elements for both arrays: ");

ra
int n = scanner.nextInt(); // Size of both arrays

// Step 3: Create two arrays of the given size

d
int[] arr1 = new int[n];
en

int[] arr2 = new int[n];

// Step 4: Input elements for the first array

ar

System.out.println("Enter " + n + " elements for the first array:");

for (int i = 0; i < n; i++) {

m

arr1[i] = scanner.nextInt(); // Store inputs in arr1

A

// Step 5: Input elements for the second array

System.out.println("Enter " + n + " elements for the second array:");

for (int i = 0; i < n; i++) {

arr2[i] = scanner.nextInt(); // Store inputs in arr2

}

// Step 6: Create a result array to store the product of corresponding elements

int[] result = new int[n];

// Step 7: Multiply corresponding elements of the two arrays

for (int i = 0; i < n; i++) {

result[i] = arr1[i] * arr2[i]; // Multiply and store in result array

ni
}

Pa
// Step 8: Print the resulting array

System.out.println("The product of corresponding elements is:");

for (int i = 0; i < n; i++) {

ra
System.out.print(result[i] + " ");
d
}
en

// Close the scanner to avoid memory leaks

scanner.close();
ar

}
m

Explanation of Steps:
A

1. Input Handling:

o The program first takes input for the size of both arrays.

o It then prompts the user to input values for both arrays.

2. Multiplying Elements:

o A loop is used to iterate through both arrays and multiply corresponding

elements.
 o The results are stored in a new array (result[]).

3. Output: The program prints the result array containing the products of the
corresponding elements from both arrays.

Input/Output Example:

• Input:

o Enter the number of elements for both arrays: 3

ni
o Enter 3 elements for the first array: 1 2 3

o Enter 3 elements for the second array: 4 5 6

Pa
• Output:

o The product of corresponding elements is: 4 10 18

ra
Edge Cases:

1. Empty Arrays: If the arrays are of size 0, the program will print nothing as there's no
d
element to multiply.
en

2. Single Element Arrays: If the arrays contain only one element, the result will simply
be the product of the two elements.
ar

Time Complexity:

• The time complexity is O(n), where n is the number of elements in each array, since
we need to iterate through all the elements once.
m
A
22. Question: How do you find the first occurrence of a
given element in an array without using a specific
algorithm in Java?

Key Concept:

To find the first occurrence of a given element in an array, you can simply iterate through the
array and check each element. Once you find the element, return its index. If the element is

ni
not found in the array, return an indicator such as -1.

Solution: Find the First Occurrence of a Given Element in an Array

Pa
package array;

import java.util.Scanner;

public class FindFirstOccurrence {

ra
public static void main(String[] args) {
d
// Step 1: Create a Scanner object to receive input
en

Scanner scanner = new Scanner(System.in);

// Step 2: Prompt the user to enter the number of elements in the array
ar

System.out.println("Enter the number of elements in the array: ");

m

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

A

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Receive input and store in the array

}

// Step 5: Input the element to search for

System.out.println("Enter the element to find the first occurrence: ");

int target = scanner.nextInt(); // The target element to search for

// Step 6: Find the first occurrence of the target element

int index = -1; // Initialize index to -1 (indicates not found)

ni
for (int i = 0; i < n; i++) {

Pa
if (arr[i] == target) {

index = i; // Set index to the current position

break; // Exit the loop once the first occurrence is found

ra
}
d
}
en

// Step 7: Output the result

if (index != -1) {
ar

System.out.println("First occurrence of element " + target + " is at index: " +

index);
m

} else {

System.out.println("Element " + target + " not found in the array.");

A

// Close the scanner to avoid memory leaks

scanner.close();

}
Explanation of Steps:

1. Input Handling:

o The program first takes the size of the array and its elements as input from
the user.

o Then, the program prompts the user for the target element to search for in
the array.

2. Searching for the First Occurrence:

ni
o A simple for loop is used to iterate through the array.

Pa
o If the current element matches the target element, the index is stored, and
the loop breaks to stop further searching.

o If the element is not found, the index remains -1.

ra
3. Output: The program prints the index of the first occurrence of the target element,
or it notifies the user that the element was not found.
d
Input/Output Example:
en

• Input:

o Enter the number of elements in the array: 5

ar

o Enter 5 elements: 10 20 30 40 50

o Enter the element to find the first occurrence: 30

m

• Output:
A

o First occurrence of element 30 is at index: 2

• Input (Element Not Found):

o Enter the number of elements in the array: 5

o Enter 5 elements: 10 20 30 40 50

o Enter the element to find the first occurrence: 60

 • Output:

o Element 60 not found in the array.

Edge Cases:

1. Element Not Found: If the target element is not in the array, the program returns -1
to indicate that the element was not found.

2. Empty Array: If the array is empty (n = 0), the program should immediately print that
the element is not found.

ni
3. Single Element Array: If the array has only one element, the search will either find

Pa
the target or return that it is not found.

Time Complexity:

• The time complexity of this approach is O(n), where n is the number of elements in
ra
the array. This is because, in the worst case, you might have to check every element
of the array.
d
en

23. Question: How do you find the first occurrence of a

given element in a sorted array using an algorithm in
ar

Java?

Key Concept:
m

If the array is sorted, you can use binary search to efficiently find the first occurrence of the
given element. In a sorted array, binary search helps reduce the search space by half in each
A

iteration, making it much faster than a linear search. However, the regular binary search
algorithm only finds an occurrence of the element, not necessarily the first occurrence. To
find the first occurrence, you can modify the binary search algorithm.

Modified Binary Search Algorithm:

• Use binary search to locate the target element.

 • Once you find an occurrence of the target, continue searching in the left half of the
array to find the first occurrence.

Approach:

1. Use binary search to find the element.

2. When you find the target element, continue searching on the left to check if it's the
first occurrence.

3. Return the index of the first occurrence or -1 if the element is not found.

ni
Solution: Binary Search for First Occurrence

Pa
package array;

import java.util.Scanner; ra
public class FirstOccurrenceBinarySearch {

// Modified binary search to find the first occurrence of the target

d
public static int findFirstOccurrence(int[] arr, int target) {
en

int low = 0, high = arr.length - 1;

int result = -1; // Initialize result to -1 (indicating not found)

ar

while (low <= high) {

m

int mid = low + (high - low) / 2; // Calculate mid point to avoid overflow

if (arr[mid] == target) {
A

result = mid; // Found target, but continue to search left for first occurrence

high = mid - 1; // Move left

} else if (arr[mid] > target) {

high = mid - 1; // Search in the left half

} else {
low = mid + 1; // Search in the right half

return result; // Return the first occurrence index, or -1 if not found

public static void main(String[] args) {

ni
// Step 1: Create a Scanner object to receive input

Pa
Scanner scanner = new Scanner(System.in);

// Step 2: Prompt the user to enter the number of elements in the array

System.out.println("Enter the number of elements in the sorted array: ");

ra
int n = scanner.nextInt(); // Size of the array
d
// Step 3: Create an array of the given size
en

int[] arr = new int[n];

// Step 4: Input sorted elements into the array

ar

System.out.println("Enter " + n + " sorted elements:");

for (int i = 0; i < n; i++) {

m

arr[i] = scanner.nextInt(); // Receive input and store in the array

A

// Step 5: Input the element to search for

System.out.println("Enter the element to find the first occurrence: ");

int target = scanner.nextInt(); // The target element to search for

// Step 6: Find the first occurrence using modified binary search

int index = findFirstOccurrence(arr, target);

// Step 7: Output the result

if (index != -1) {

System.out.println("First occurrence of element " + target + " is at index: " +

index);

} else {

ni
System.out.println("Element " + target + " not found in the array.");

Pa
// Close the scanner to avoid memory leaks

scanner.close();

}
ra
}
d
Explanation of Steps:
en

1. Input Handling:

o The program takes input for the size and elements of a sorted array.
ar

o It also takes input for the target element to find.

m

2. Modified Binary Search Logic:

o The function findFirstOccurrence() performs a binary search to find the first

A

occurrence of the target element.

o Whenever an occurrence of the target element is found, the search continues

in the left half of the array (high = mid - 1) to check for earlier occurrences.

o The final value of result will be the index of the first occurrence.

3. Output: The program prints the index of the first occurrence of the target element or
notifies the user that the element was not found.
Input/Output Example:

• Input:

o Enter the number of elements in the sorted array: 6

o Enter 6 sorted elements: 1 2 2 2 3 4

o Enter the element to find the first occurrence: 2

• Output:

ni
o First occurrence of element 2 is at index: 1

• Input (Element Not Found):

Pa
o Enter the number of elements in the sorted array: 6

o Enter 6 sorted elements: 1 2 3 4 5 6

o
ra
Enter the element to find the first occurrence: 7

• Output:
d
o Element 7 not found in the array.
en

Edge Cases:

1. Element Not Found: If the target element is not present in the array, the algorithm
ar

returns -1.

2. Single Element Array: If the array has only one element, the search will either find
m

the target or return that it is not found.

3. All Elements the Same: If all elements in the array are the same as the target, the
A

algorithm will return index 0.

Time Complexity:

• The time complexity of this modified binary search is O(log n), where n is the number
of elements in the array. This is because binary search reduces the search space by
half in each iteration.
Space Complexity:

• The space complexity is O(1), as we are using a constant amount of extra space
(variables for pointers and the result).

Use predefined method

you can use the predefined method Arrays.binarySearch() from the java.util.Arrays class to
search for an element in a sorted array. However, by default, Arrays.binarySearch() returns
the index of any occurrence of the target element in the array, not necessarily the first

ni
occurrence.

To find the first occurrence using Arrays.binarySearch(), you can:

Pa
1. Use Arrays.binarySearch() to locate an occurrence of the element.

2. If the element is found, manually check the previous elements to find the first
occurrence.
ra
Approach Using Arrays.binarySearch():
d
1. Use Arrays.binarySearch() to find an occurrence of the element.
en

2. If found, check the elements to the left to find the first occurrence.

3. Return the index of the first occurrence or -1 if the element is not found.
ar

Solution: Using Arrays.binarySearch() to Find the First Occurrence

package array;
m

import java.util.Arrays;
A

import java.util.Scanner;

public class FirstOccurrenceWithBinarySearch {

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Prompt the user to enter the number of elements in the sorted array

System.out.println("Enter the number of elements in the sorted array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input sorted elements into the array

ni
System.out.println("Enter " + n + " sorted elements:");

Pa
for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Receive input and store in the array

}
ra
// Step 5: Input the element to search for
d
System.out.println("Enter the element to find the first occurrence: ");
en

int target = scanner.nextInt(); // The target element to search for

// Step 6: Use Arrays.binarySearch to find an occurrence

ar

int index = Arrays.binarySearch(arr, target);

// Step 7: If found, move left to find the first occurrence

m

if (index >= 0) {
A

// Check for earlier occurrences

while (index > 0 && arr[index - 1] == target) {

index--; // Move to the left if the previous element is also the target

System.out.println("First occurrence of element " + target + " is at index: " +

index);
} else {

System.out.println("Element " + target + " not found in the array.");

// Close the scanner to avoid memory leaks

scanner.close();

ni
}

Pa
Explanation of Steps:

1. Input Handling:

o The program takes input for the size and elements of the sorted array, as well
ra
as the target element.

2. Using Arrays.binarySearch():
d
o The predefined method Arrays.binarySearch(arr, target) is used to find an
en

occurrence of the target element in the sorted array. It returns the index of
the target if found, or a negative value if the target is not found.
ar

3. Checking for the First Occurrence:

o If binarySearch finds an occurrence, we check the previous elements in the

m

array (using a while loop) to ensure we get the first occurrence.

4. Output: The program prints the index of the first occurrence, or notifies the user if
A

the element is not found.

Input/Output Example:

• Input:

o Enter the number of elements in the sorted array: 6

o Enter 6 sorted elements: 1 2 2 2 3 4

 o Enter the element to find the first occurrence: 2

• Output:

o First occurrence of element 2 is at index: 1

• Input (Element Not Found):

o Enter the number of elements in the sorted array: 6

o Enter 6 sorted elements: 1 2 3 4 5 6

ni
o Enter the element to find the first occurrence: 7

• Output:

Pa
o Element 7 not found in the array.

Edge Cases:
ra
1. Element Not Found: If binarySearch returns a negative value, the element is not
found in the array.
d
2. Single Element Array: If the array has only one element, the search will either find
en

the target or return that it is not found.

3. All Elements the Same: If all elements in the array are the same as the target, the
algorithm will return the first index.
ar

Time Complexity:
m

• The time complexity of Arrays.binarySearch() is O(log n), where n is the number of

elements in the array. After finding an occurrence, the leftward check for the first
occurrence may take an additional O(k), where k is the number of elements equal to
A

the target, so the total complexity in the worst case is O(log n + k).

Space Complexity:

• The space complexity is O(1) because no extra space is used beyond the input array
and a few variables.
24. Question: How do you sort an array in ascending
order using built-in functions in Java?

Key Concept:

To sort an array in ascending order in Java, you can use the Arrays.sort() method from the
java.util.Arrays class. This method efficiently sorts the array using the Timsort algorithm,
which has a time complexity of O(n log n) in the worst case.

ni
Approach:

1. Import the java.util.Arrays class.

Pa
2. Use Arrays.sort() to sort the array in ascending order.

3. Print the sorted array. ra

Solution: Sorting an Array in Ascending Order Using Arrays.sort()

package array;
d
import java.util.Arrays;
en

import java.util.Scanner;

public class SortArrayAscending {

ar

public static void main(String[] args) {

m

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

A

// Step 2: Prompt the user to enter the number of elements in the array

System.out.println("Enter the number of elements you want to store in the array:

");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Receive input and store in the array

ni
// Step 5: Sort the array in ascending order using Arrays.sort()

Pa
Arrays.sort(arr);

// Step 6: Print the sorted array

System.out.println("The array sorted in ascending order is: ");

ra
for (int i = 0; i < n; i++) {
d
System.out.print(arr[i] + " ");
en

// Close the scanner to avoid memory leaks

ar

scanner.close();

}
m

}
A

Explanation of Steps:

1. Input Handling: The program takes input for the size and elements of the array from
the user.

2. Sorting with Arrays.sort():

o The Arrays.sort(arr) method is used to sort the array in ascending order.

 o This method modifies the array in-place and arranges the elements in
ascending order.

3. Output: The program prints the sorted array after applying the Arrays.sort() method.

Input/Output Example:

• Input:

o Enter the number of elements you want to store in the array: 5

ni
o Enter 5 elements: 50 20 40 10 30

• Output:

Pa
o The array sorted in ascending order is: 10 20 30 40 50

Edge Cases: ra
1. Empty Array: If the array has zero elements, the program will print nothing as there
are no elements to sort.
d
2. Single Element Array: If the array has only one element, it will remain unchanged
after sorting.
en

3. Array Already Sorted: If the array is already sorted, the method will recognize that no
changes are needed.
ar

Time Complexity:

• The time complexity of Arrays.sort() is O(n log n), where n is the number of elements
m

in the array. This is because the Arrays.sort() method uses the Timsort algorithm,
which is highly efficient for real-world data.
A

Space Complexity:

• The space complexity is O(n) due to the use of temporary arrays in the internal
Timsort implementation for merging sorted runs.
25. Question: How do you sort an array in descending
order using built-in functions in Java?

Key Concept:

To sort an array in descending order, you can use the Arrays.sort() method in combination
with Collections.reverseOrder(). However, Collections.reverseOrder() works only with non-
primitive arrays (like Integer[], not int[]). Therefore, you must first convert the array to an
Integer[] if you're working with primitive int arrays.

ni
Approach:

Pa
1. Convert the array from int[] to Integer[] (if necessary).

2. Use Arrays.sort() with Collections.reverseOrder() to sort the array in descending

order.
ra
3. Print the sorted array.

Solution: Sorting an Array in Descending Order Using Arrays.sort() and

d
Collections.reverseOrder()
en

package array;

import java.util.Arrays;
ar

import java.util.Collections;
m

import java.util.Scanner;

public class SortArrayDescending {

A

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Prompt the user to enter the number of elements in the array
System.out.println("Enter the number of elements you want to store in the array:
");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an Integer array (non-primitive) of the given size

Integer[] arr = new Integer[n];

// Step 4: Input elements into the array

ni
System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

Pa
arr[i] = scanner.nextInt(); // Receive input and store in the array

}
ra
// Step 5: Sort the array in descending order using Arrays.sort() with
Collections.reverseOrder()
d
Arrays.sort(arr, Collections.reverseOrder());
en

// Step 6: Print the sorted array

System.out.println("The array sorted in descending order is: ");

ar

for (int i = 0; i < n; i++) {

System.out.print(arr[i] + " ");

m

}
A

// Close the scanner to avoid memory leaks

scanner.close();

}
Explanation of Steps:

1. Input Handling: The program takes input for the size and elements of the array.

2. Sorting with Arrays.sort() and Collections.reverseOrder():

o The Arrays.sort(arr, Collections.reverseOrder()) method sorts the Integer[]

array in descending order.

o Collections.reverseOrder() works with non-primitive types, so the array needs

to be of type Integer[] rather than int[].

ni
3. Output: The program prints the sorted array after sorting it in descending order.

Pa
Input/Output Example:

• Input:

o Enter the number of elements you want to store in the array: 5

ra
o Enter 5 elements: 10 50 30 20 40
d
• Output:
en

o The array sorted in descending order is: 50 40 30 20 10

Edge Cases:
ar

1. Empty Array: If the array has zero elements, nothing will be printed, as there are no
elements to sort.
m

2. Single Element Array: If the array has only one element, it will remain unchanged
after sorting.
A

3. Array Already Sorted in Descending Order: If the array is already sorted in descending
order, the method will recognize that no changes are needed.

Time Complexity:

• The time complexity of Arrays.sort() with Collections.reverseOrder() is O(n log n),

where n is the number of elements in the array. This is because the Arrays.sort()
method uses the Timsort algorithm, which is highly efficient.
Space Complexity:

• The space complexity is O(n) due to the use of temporary arrays in the internal
sorting process of Arrays.sort() and the additional non-primitive array required.

Note on Primitive Arrays (int[]):

If you're dealing with primitive int[] arrays, you'll need to either:

1. Manually convert the array to Integer[] (as shown in this example).

ni
2. Sort the array in ascending order using Arrays.sort() and then reverse it manually if
you wish to avoid using Collections.reverseOrder().

Pa
26. Question: How do you join two arrays in Java? Provide
all possible solutions.
ra
Key Concept:
d
In Java, joining (or concatenating) two arrays can be done in multiple ways depending on
your approach. This involves combining the elements of two arrays into a single larger array.
en

Here, we will explore different solutions to join two arrays.

Possible Solutions to Join Two Arrays in Java:

ar

1. Manual Copying (Using Loops)

m

2. Using System.arraycopy()

3. Using Arrays.copyOf()
A

4. Using Streams (Java 8 and above)

5. Using List and ArrayList (for non-primitive types)

Solution 1: Manual Copying (Using Loops)

package array;

import java.util.Scanner;

public class JoinArraysUsingLoops {

public static void main(String[] args) {

// Step 1: Create two arrays to join

ni
int[] arr1 = {1, 2, 3};

Pa
int[] arr2 = {4, 5, 6};

// Step 2: Create a new array to store the joined arrays

ra
int[] joinedArray = new int[arr1.length + arr2.length];

// Step 3: Copy elements of the first array into the joined array
d
for (int i = 0; i < arr1.length; i++) {
en

joinedArray[i] = arr1[i];

}
ar

// Step 4: Copy elements of the second array into the joined array

for (int i = 0; i < arr2.length; i++) {

m

joinedArray[arr1.length + i] = arr2[i];
A

// Step 5: Print the joined array

System.out.println("Joined Array:");

for (int i = 0; i < joinedArray.length; i++) {

System.out.print(joinedArray[i] + " ");

}

Explanation:

• First, a new array joinedArray is created with a length equal to the sum of the two
arrays.

ni
• The elements of the first array are copied using a loop, followed by the elements of
the second array.

Pa
Output:

• Joined Array: 1 2 3 4 5 6 ra
Solution 2: Using System.arraycopy()
d
The System.arraycopy() method allows you to copy elements from one array to another
efficiently.
en

package array;
ar

import java.util.Scanner;

public class JoinArraysUsingSystemArrayCopy {

m

public static void main(String[] args) {

A

// Step 1: Create two arrays to join

int[] arr1 = {1, 2, 3};

int[] arr2 = {4, 5, 6};

// Step 2: Create a new array to store the joined arrays

int[] joinedArray = new int[arr1.length + arr2.length];

// Step 3: Use System.arraycopy to copy arr1 and arr2 into joinedArray

System.arraycopy(arr1, 0, joinedArray, 0, arr1.length);

System.arraycopy(arr2, 0, joinedArray, arr1.length, arr2.length);

// Step 4: Print the joined array

System.out.println("Joined Array:");

for (int i = 0; i < joinedArray.length; i++) {

ni
System.out.print(joinedArray[i] + " ");

Pa
}

}
ra
Explanation:
d
• System.arraycopy(src, srcPos, dest, destPos, length) copies elements from src starting
at srcPos to dest starting at destPos.
en

• This method is efficient and commonly used for array operations.

Output:
ar

• Joined Array: 1 2 3 4 5 6
m
A
Solution 3: Using Arrays.copyOf()

Arrays.copyOf() can be used to copy an array, and you can use it twice to create a joined
array.

package array;

import java.util.Arrays;

public class JoinArraysUsingCopyOf {

ni
public static void main(String[] args) {

Pa
// Step 1: Create two arrays to join

int[] arr1 = {1, 2, 3};

int[] arr2 = {4, 5, 6};

ra
// Step 2: Create a new array by copying arr1 and then arr2

int[] joinedArray = Arrays.copyOf(arr1, arr1.length + arr2.length);

d
// Step 3: Copy arr2 elements to joinedArray using System.arraycopy
en

System.arraycopy(arr2, 0, joinedArray, arr1.length, arr2.length);

ar

// Step 4: Print the joined array

System.out.println("Joined Array:");
m

for (int i = 0; i < joinedArray.length; i++) {

System.out.print(joinedArray[i] + " ");

A

}
Explanation:

• Arrays.copyOf() creates a copy of arr1 with extra space to accommodate arr2.

• Then, System.arraycopy() is used to append the elements of arr2 to the newly

created array.

Output:

• Joined Array: 1 2 3 4 5 6

ni
Solution 4: Using Streams (Java 8 and above)

Pa
If you're using Java 8 or later, you can use streams to concatenate arrays.

package array; ra
import java.util.Arrays;

import java.util.stream.IntStream;
d
public class JoinArraysUsingStreams {
en

public static void main(String[] args) {

// Step 1: Create two arrays to join

ar

int[] arr1 = {1, 2, 3};

m

int[] arr2 = {4, 5, 6};

// Step 2: Join the two arrays using streams

A

int[] joinedArray = IntStream.concat(Arrays.stream(arr1),

Arrays.stream(arr2)).toArray();

// Step 3: Print the joined array

System.out.println("Joined Array:");

for (int i = 0; i < joinedArray.length; i++) {

System.out.print(joinedArray[i] + " ");

Explanation:

• Arrays.stream(arr1) creates a stream from arr1.

ni
• IntStream.concat() concatenates two streams.

Pa
• toArray() converts the result back into an array.

Output:

• Joined Array: 1 2 3 4 5 6
ra
Solution 5: Using List and ArrayList (For Non-Primitive Types)
d
If you're working with non-primitive arrays (e.g., Integer[]), you can use List and ArrayList to
en

join the arrays.

package array;
ar

import java.util.ArrayList;
m

import java.util.Arrays;

import java.util.List;
A

public class JoinArraysUsingArrayList {

public static void main(String[] args) {

// Step 1: Create two Integer arrays to join

Integer[] arr1 = {1, 2, 3};

Integer[] arr2 = {4, 5, 6};

// Step 2: Convert arrays to lists and add them to a new list

List<Integer> list = new ArrayList<>(Arrays.asList(arr1));

list.addAll(Arrays.asList(arr2));

// Step 3: Convert the list back to an array

Integer[] joinedArray = list.toArray(new Integer[0]);

// Step 4: Print the joined array

ni
System.out.println("Joined Array:");

Pa
for (int i = 0; i < joinedArray.length; i++) {

System.out.print(joinedArray[i] + " ");

}
ra
}
d
}
en

Explanation:

• Convert the arrays to lists using Arrays.asList().

ar

• Use list.addAll() to combine the lists.

• Convert the list back to an array using toArray().

m

Output:

• Joined Array: 1 2 3 4 5 6
A

Summary of Solutions:

1. Manual Copying (Using Loops): Basic approach with full control over the copying
process.

2. Using System.arraycopy(): Fast and efficient array copying.

 3. Using Arrays.copyOf(): An easy way to extend one array and concatenate another.

4. Using Streams (Java 8 and above): A modern, clean solution using Java 8 streams.

5. Using List and ArrayList: Useful for non-primitive types like Integer[].

27. Question: How do you calculate the average of an

array in Java using a simple loop, Java 8 streams, and the

ni
Google Guava library?
Here are the three approaches to calculate the average:

Pa
1. Using a Simple Loop

2. Using Java 8 Streams

3. Using Google Guava Library

ra
Solution 1: Calculate Average Using a Simple Loop
d
In this approach, you iterate over the array, sum all the elements, and then divide the sum
en

by the length of the array to get the average.

package array;
ar

import java.util.Scanner;

public class AverageUsingSimpleLoop {

m

public static void main(String[] args) {

A

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

ni
}

Pa
// Step 5: Calculate the sum using a simple loop

int sum = 0;

for (int i = 0; i < n; i++) {

ra
sum += arr[i]; // Add each element to the sum
d
}
en

// Step 6: Calculate the average

double average = (double) sum / n;

ar

// Step 7: Print the average

System.out.println("Average of the array is: " + average);

m

// Close the scanner

A

scanner.close();

}
Explanation:

• A simple loop iterates through the array to calculate the sum.

• The average is calculated by dividing the sum by the number of elements.

Example Output:

• Input:

o Enter the number of elements: 5

ni
o Enter 5 elements: 10 20 30 40 50

• Output:

Pa
o Average of the array is: 30.0
ra
Solution 2: Calculate Average Using Java 8 Streams

Java 8 introduced streams, which can be used to process sequences of elements in a

d
functional style. You can use the IntStream class to calculate the average of an array.
en

package array;

import java.util.Arrays;
ar

public class AverageUsingStreams {

public static void main(String[] args) {

m

// Step 1: Define an array

A

int[] arr = {10, 20, 30, 40, 50};

// Step 2: Calculate the average using streams

double average = Arrays.stream(arr) // Convert the array to an IntStream

.average() // Get the average

.orElse(0); // Provide a default value in case of an empty array

// Step 3: Print the average

System.out.println("Average of the array is: " + average);

Explanation:

• Arrays.stream(arr) converts the array into an IntStream.

ni
• The average() method computes the average of the elements.

Pa
• The orElse(0) method provides a default value in case the array is empty.

Example Output:

• Input: {10, 20, 30, 40, 50}

ra
• Output: Average of the array is: 30.0
d
Solution 3: Calculate Average Using Google Guava Library
en

The Google Guava library provides utility methods for various operations on collections and
arrays. You can use the Ints.asList() method to convert an array to a list and then compute
ar

the average manually.

1. Add the Guava dependency in your pom.xml (for Maven):

m

<dependency>
A

<groupId>com.google.guava</groupId>

<artifactId>guava</artifactId>

<version>31.0.1-jre</version> <!-- Or the latest version -->

</dependency>

package array;
import com.google.common.primitives.Ints;

import java.util.List;

public class AverageUsingGuava {

public static void main(String[] args) {

// Step 1: Define an array

int[] arr = {10, 20, 30, 40, 50};

ni
// Step 2: Convert the array to a list using Guava

Pa
List<Integer> list = Ints.asList(arr);

// Step 3: Calculate the sum using a simple loop

int sum = 0;
ra
for (int num : list) {
d
sum += num;
en

// Step 4: Calculate the average

ar

double average = (double) sum / list.size();

// Step 5: Print the average

m

System.out.println("Average of the array is: " + average);

A

Explanation:

• Ints.asList(arr) converts the primitive int[] array to a List<Integer>.

• The sum is calculated manually using a loop, and the average is computed by dividing
the sum by the list size.
Example Output:

• Input: {10, 20, 30, 40, 50}

• Output: Average of the array is: 30.0

Summary:

Approach Key Method

Simple Loop Manual loop for sum

ni
Java 8 Streams Arrays.stream() + .average()

Pa
Google Guava Library Ints.asList() + manual sum

Each of these methods is efficient and suitable for different situations depending on whether
you are using plain Java, Java 8+, or libraries like Guava.
ra
28. Question: How do you shift all zero elements to the
d
right side of the array in Java?
en

Key Concept:
ar

The task is to shift all the zeros in an array to the right side while maintaining the relative
order of non-zero elements. This can be done in several ways, but the most efficient
approach is to use a two-pointer technique. You can move all non-zero elements to the front
m

and fill the remaining positions with zeros.

Approach:
A

1. Use a pointer to track the position of the next non-zero element.

2. Traverse the array and whenever a non-zero element is found, place it in the next
available position in the array.

3. After all non-zero elements are shifted, fill the remaining positions with zeros.
Solution: Shift All Zeros to the Right

Explanation of Steps:

1. Input Handling: The program first takes input for the size and elements of the array.

2. Shift Non-Zero Elements:

o We use a variable index to track the position where the next non-zero
element should be placed.

ni
o As we iterate through the array, each non-zero element is placed at the
position tracked by index, and then index is incremented.

Pa
3. Fill Zeros: Once all non-zero elements are placed, the remaining positions (from index
to the end of the array) are filled with zeros.

4. Output: The modified array is printed.

ra
Input/Output Example:
d
• Input:
en

o Enter the number of elements in the array: 6

o Enter 6 elements: 0 1 0 3 12 0
ar

• Output:

o Array after shifting all zeros to the right: 1 3 12 0 0 0

m

Edge Cases:
A

1. All Zeros: If the array contains only zeros, the output will be the same array.

2. No Zeros: If there are no zeros in the array, the array remains unchanged.

3. Empty Array: If the array is empty (n = 0), the program should handle this case
gracefully.
Time Complexity:

• The time complexity of this solution is O(n), where n is the number of elements in
the array. This is because we make one pass through the array to move the non-zero
elements and another pass to fill the zeros.

Space Complexity:

• The space complexity is O(1) because no additional arrays or data structures are
used, and the shifting is done in-place.

ni
Pa
29. Question: How do you check the equality of two arrays
in Java?

In Java, you can check the equality of two arrays in different ways. Equality can be checked
ra
based on whether the arrays contain the same elements in the same order, or in the case of
multi-dimensional arrays, whether the arrays are deeply equal (including any nested arrays).
d
Here are different ways to check the equality of two arrays:
en

1. Using Arrays.equals() (for 1D arrays)

2. Using Arrays.deepEquals() (for multi-dimensional arrays)

ar

3. Manual comparison using a loop

4. Using Arrays.mismatch() to find differences

m
A

Solution 1: Using Arrays.equals() (for 1D arrays)

The Arrays.equals() method is used to check whether two arrays of primitive or object types
are equal, meaning they contain the same elements in the same order.

package array;

import java.util.Arrays;

public class CheckEqualityUsingEquals {

public static void main(String[] args) {

// Step 1: Define two 1D arrays

int[] arr1 = {1, 2, 3};

int[] arr2 = {1, 2, 3};

// Step 2: Use Arrays.equals() to check equality

boolean areEqual = Arrays.equals(arr1, arr2);

ni
// Step 3: Print the result

Pa
if (areEqual) {

System.out.println("The arrays are equal.");

} else {
ra
System.out.println("The arrays are not equal.");
d
}
en

}
ar

Explanation:

• Arrays.equals(arr1, arr2) compares the two arrays element by element. If all

m

elements are equal and the arrays have the same length, it returns true; otherwise,
it returns false.
A

Example Output:

• Output: The arrays are equal.

Solution 2: Using Arrays.deepEquals() (for multi-dimensional arrays)

For multi-dimensional arrays, Arrays.equals() is not sufficient, as it only compares the top-
level array. To check equality for nested arrays (e.g., 2D arrays), you need to use
Arrays.deepEquals().

package array;

import java.util.Arrays;

ni
public class CheckEqualityUsingDeepEquals {

public static void main(String[] args) {

Pa
// Step 1: Define two 2D arrays

int[][] arr1 = {{1, 2}, {3, 4}};

ra
int[][] arr2 = {{1, 2}, {3, 4}};

// Step 2: Use Arrays.deepEquals() to check equality

d
boolean areEqual = Arrays.deepEquals(arr1, arr2);
en

// Step 3: Print the result

ar

if (areEqual) {

System.out.println("The 2D arrays are equal.");

m

} else {

System.out.println("The 2D arrays are not equal.");

A

}
Explanation:

• Arrays.deepEquals(arr1, arr2) recursively checks whether all elements (including

nested arrays) are equal.

Example Output:

• Output: The 2D arrays are equal.

•

ni
Solution 3: Manual Comparison Using a Loop

Pa
You can manually compare the elements of two arrays using a loop. This approach works for
both primitive and object arrays. ra
package array;

public class CheckEqualityUsingLoop {

d
public static void main(String[] args) {
en

// Step 1: Define two 1D arrays

int[] arr1 = {1, 2, 3};

ar

int[] arr2 = {1, 2, 3};

// Step 2: Check if both arrays are of the same length

m

if (arr1.length != arr2.length) {
A

System.out.println("The arrays are not equal.");

return; // Exit if the lengths are not the same

// Step 3: Compare elements of both arrays

boolean areEqual = true;

for (int i = 0; i < arr1.length; i++) {

if (arr1[i] != arr2[i]) {

areEqual = false;

break; // Exit the loop as soon as a mismatch is found

ni
// Step 4: Print the result

Pa
if (areEqual) {

System.out.println("The arrays are equal.");

} else {
ra
System.out.println("The arrays are not equal.");
d
}
en

}
ar

Explanation:

• This solution compares the length of both arrays first. If the lengths are different,
m

they are not equal.

• Then, it iterates through the arrays and compares each element. If a mismatch is
A

found, the arrays are considered unequal.

Example Output:

• Output: The arrays are equal.

Solution 4: Using Arrays.mismatch() (for finding differences)

The Arrays.mismatch() method can be used to check the first index where the two arrays
differ. If it returns -1, the arrays are equal.

package array;

import java.util.Arrays;

public class CheckEqualityUsingMismatch {

ni
public static void main(String[] args) {

Pa
// Step 1: Define two 1D arrays

int[] arr1 = {1, 2, 3};

int[] arr2 = {1, 2, 4};

ra
// Step 2: Use Arrays.mismatch() to find the first difference
d
int mismatchIndex = Arrays.mismatch(arr1, arr2);
en

// Step 3: Print the result

if (mismatchIndex == -1) {
ar

System.out.println("The arrays are equal.");

} else {
m

System.out.println("The arrays are not equal. They differ at index: " +

mismatchIndex);
A

}
Explanation:

• Arrays.mismatch(arr1, arr2) returns the index of the first mismatching element. If no

mismatch is found, it returns -1.

Example Output:

• Output: The arrays are not equal. They differ at index: 2

•

ni
Summary of Solutions:

Pa
Method Description

Arrays.equals() Compares 1D arrays element by element

Arrays.deepEquals() Compares multi-dimensional arrays recursively

ra
Manual Loop Comparison Custom loop-based comparison

Arrays.mismatch() Finds the first mismatching element

d
Each of these methods has its specific use case, depending on whether you're comparing 1D
en

arrays, multi-dimensional arrays, or you want to find exactly where two arrays differ
ar
m
A
30. Question: How do you search for an element in an
array in Java?

You can search for an element in an array using various methods depending on whether the
array is sorted or unsorted, and the efficiency you require. The most common approaches
are:

1. Linear Search: For unsorted arrays.

ni
2. Binary Search: For sorted arrays, which is more efficient than linear search.
3. Using Built-in Methods: Such as Arrays.binarySearch() for sorted arrays.

Pa
Solution 1: Linear Search (For Unsorted Arrays)

In linear search, you traverse through the array element by element until you find the target
element. It works for both sorted and unsorted arrays, but it is not very efficient for large
ra
arrays.
d
package array;
en

import java.util.Scanner;

public class LinearSearch {

ar

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

m

Scanner scanner = new Scanner(System.in);

A

// Step 2: Input the number of elements in the array

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

// Step 5: Input the element to search for

ni
System.out.println("Enter the element to search: ");

Pa
int target = scanner.nextInt();

// Step 6: Perform linear search

boolean found = false;

ra
for (int i = 0; i < n; i++) {
d
if (arr[i] == target) {
en

System.out.println("Element " + target + " found at index: " + i);

found = true;
ar

break;

}
m

}
A

// Step 7: If element not found

if (!found) {

System.out.println("Element " + target + " not found in the array.");

// Close the scanner

scanner.close();

Explanation:

• The program iterates through the array using a for loop. If the target element is
found, the index is printed. If the target is not found, the program prints a message

ni
saying the element is not present in the array.

Example Output:

Pa
• Input:
o Enter the number of elements: 5
o
ra
Enter 5 elements: 10 20 30 40 50
o Enter the element to search: 30
• Output: Element 30 found at index: 2
d
Solution 2: Binary Search (For Sorted Arrays)
en

In binary search, you repeatedly divide the search space in half by comparing the middle
element with the target. This method only works for sorted arrays and is much more
ar

efficient than linear search, with a time complexity of O(log n).

m

package array;

import java.util.Scanner;
A

import java.util.Arrays;

public class BinarySearch {

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements in the array

System.out.println("Enter the number of elements in the sorted array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create a sorted array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array (assume the user enters sorted elements)

ni
System.out.println("Enter " + n + " sorted elements:");

Pa
for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

}
ra
// Step 5: Input the element to search for
d
System.out.println("Enter the element to search: ");
en

int target = scanner.nextInt();

// Step 6: Perform binary search

ar

int left = 0, right = n - 1;

boolean found = false;

m

while (left <= right) {

A

int mid = left + (right - left) / 2; // Calculate mid index

if (arr[mid] == target) {

System.out.println("Element " + target + " found at index: " + mid);

found = true;

break;
}

// If target is greater, ignore the left half

if (arr[mid] < target) {

left = mid + 1;

// If target is smaller, ignore the right half

ni
else {

Pa
right = mid - 1;

}
ra
// Step 7: If element not found
d
if (!found) {
en

System.out.println("Element " + target + " not found in the array.");

}
ar

// Close the scanner

scanner.close();
m

}
A

Explanation:

• Binary search works by checking the middle element. If the target is smaller than the
middle, the search space is reduced to the left half, and if larger, the search space is
reduced to the right half.
• This method is only applicable for sorted arrays.
Example Output:

• Input:
o Enter the number of elements: 5
o Enter 5 sorted elements: 10 20 30 40 50
o Enter the element to search: 30
• Output: Element 30 found at index: 2

Solution 3: Using Arrays.binarySearch() (For Sorted Arrays)

ni
Java provides a built-in method Arrays.binarySearch() that can be used to perform binary

Pa
search directly on a sorted array.

package array;

import java.util.Arrays;
ra
import java.util.Scanner;
d
public class BinarySearchUsingArrays {
en

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

ar

Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements in the sorted array

m

System.out.println("Enter the number of elements in the sorted array: ");

A

int n = scanner.nextInt(); // Size of the array

// Step 3: Create a sorted array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array (assume the user enters sorted elements)

System.out.println("Enter " + n + " sorted elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

// Step 5: Input the element to search for

System.out.println("Enter the element to search: ");

int target = scanner.nextInt();

ni
// Step 6: Use Arrays.binarySearch() to search for the element

Pa
int index = Arrays.binarySearch(arr, target);

// Step 7: Print the result

if (index >= 0) {
ra
System.out.println("Element " + target + " found at index: " + index);
d
} else {
en

System.out.println("Element " + target + " not found in the array.");

}
ar

// Close the scanner

scanner.close();
m

}
A

Explanation:

• Arrays.binarySearch(arr, target) returns the index of the target element if found, or a

negative value if the element is not present in the array.
Example Output:

• Input:
o Enter the number of elements: 5
o Enter 5 sorted elements: 10 20 30 40 50
o Enter the element to search: 30
• Output: Element 30 found at index: 2

Summary:

ni
Method Use Case Time Complexity

Pa
Linear Search For unsorted arrays or small arrays O(n)

Binary Search For sorted arrays (manual implementation) O(log n)

Arrays.binarySearch() For sorted arrays (built-in method) O(log n)

ra
Each method has its specific use case. For unsorted arrays, linear search is the go-to
method. For sorted arrays, binary search (either manual or using the built-in
d
Arrays.binarySearch()) is much more efficient.
en
ar
m
A
31. Question: How do you reverse an array in Java without
using any built-in method and without using any extra
array?

Key Concept:

To reverse an array in place (i.e., without using an additional array), you can use a two-

ni
pointer approach. One pointer starts at the beginning of the array and the other starts at
the end. You swap the elements at these two pointers and then move both pointers toward
the center until they meet or cross each other.

Pa
Approach:

1. Initialize two pointers: one at the start (i = 0) and the other at the end (j =
ra
array.length - 1).
2. Swap the elements at these two pointers.
d
3. Increment the start pointer and decrement the end pointer.
4. Repeat this process until the two pointers meet or cross each other.
en

Solution: Reverse an Array Without Using Built-in Methods or Extra Arrays

ar

package array;

import java.util.Scanner;
m

public class ReverseArrayInPlace {

A

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements in the array

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

ni
arr[i] = scanner.nextInt(); // Input each element

Pa
}

// Step 5: Reverse the array using a two-pointer approach

int start = 0;
ra
int end = n - 1;
d
while (start < end) {
en

// Swap elements at 'start' and 'end'

int temp = arr[start];

ar

arr[start] = arr[end];

arr[end] = temp;
m

// Move pointers
A

start++;

end--;

// Step 6: Print the reversed array

System.out.println("Reversed array:");
for (int i = 0; i < n; i++) {

System.out.print(arr[i] + " ");

// Close the scanner

scanner.close();

ni
}

Pa
Explanation of Steps: ra
1. Input Handling: The user provides the size of the array and its elements.
2. Two-Pointer Approach:
o A start pointer is initialized at the beginning (0) and an end pointer is
d
initialized at the end (n - 1).
en

o The elements at the start and end positions are swapped.

o The start pointer is incremented, and the end pointer is decremented.
o This process continues until the start pointer is greater than or equal to the
ar

end pointer.
3. Output: After reversing, the program prints the reversed array.
m

Input/Output Example:
A

• Input:
o Enter the number of elements: 5
o Enter 5 elements: 1 2 3 4 5
• Output:
o Reversed array: 5 4 3 2 1
Edge Cases:

1. Empty Array: If the array has zero elements, the program should handle this
gracefully without performing any swaps.
2. Single Element Array: If the array has only one element, it will remain unchanged
after the reverse operation.
3. Odd/Even Length Array: The approach works for both odd and even length arrays.
For odd-length arrays, the middle element will remain in the same position.

ni
Time Complexity:

Pa
• The time complexity of this approach is O(n), where n is the number of elements in
the array. This is because we swap each element exactly once.

Space Complexity:
ra
• The space complexity is O(1), since no additional arrays or data structures are used,
and the reversal is done in place.
d
en

32. Question: How do you find the second largest element

ar

in an array in Java?

Key Concept:
m

To find the second largest element in an array, you can traverse the array once, keeping
A

track of both the largest and second largest elements. The idea is to compare each element
with the current largest, and if it is larger, update the second largest and largest accordingly.

Approach:

1. Initialize two variables firstLargest and secondLargest to hold the largest and second
largest values, respectively.
2. Traverse the array:
 o If the current element is larger than firstLargest, update secondLargest to be
firstLargest, and update firstLargest to the current element.
o Else if the current element is smaller than firstLargest but larger than
secondLargest, update secondLargest to the current element.
3. After the loop, secondLargest will hold the second largest value in the array.

Solution: Find the Second Largest Element in the Array

package array;

ni
import java.util.Scanner;

Pa
public class SecondLargestInArray {

public static void main(String[] args) { ra

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

d
// Step 2: Input the number of elements in the array
en

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

ar

// Step 3: Create an array of the given size

int[] arr = new int[n];

m

// Step 4: Input elements into the array

A

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

// Step 5: Find the second largest element

if (n < 2) {

System.out.println("Array should have at least two elements.");

} else {

int firstLargest = Integer.MIN_VALUE;

int secondLargest = Integer.MIN_VALUE;

// Traverse the array to find the largest and second largest

ni
for (int i = 0; i < n; i++) {

Pa
if (arr[i] > firstLargest) {

secondLargest = firstLargest;

firstLargest = arr[i];
ra
} else if (arr[i] > secondLargest && arr[i] != firstLargest) {
d
secondLargest = arr[i];
en

}
ar

// Step 6: Output the second largest element

if (secondLargest == Integer.MIN_VALUE) {
m

System.out.println("There is no second largest element in the array.");

A

} else {

System.out.println("The second largest element in the array is: " +

secondLargest);

// Close the scanner

scanner.close();

Explanation of Steps:

1. Input Handling: The program takes input for the size of the array and the array
elements.

ni
2. Finding the Second Largest:
o We initialize firstLargest and secondLargest with Integer.MIN_VALUE to

Pa
ensure any element in the array can replace them.
o Traverse the array:
▪ If the current element is greater than firstLargest, update
secondLargest to the value of firstLargest, and then set firstLargest to
ra
the current element.
▪ If the current element is greater than secondLargest but less than
d
firstLargest, update secondLargest.
3. Edge Cases:
en

o If the array has fewer than two elements, the program prints an error
message.
ar

o If all elements are the same, the program will print that there is no second
largest element.
4. Output: The second largest element is printed after the traversal.
m

Input/Output Example:
A

• Input 1 (Valid Case):

o Enter the number of elements: 6
o Enter 6 elements: 10 20 20 40 50 30
• Output:
o The second largest element in the array is: 40
• Input 2 (No Second Largest Case):
 o Enter the number of elements: 4
o Enter 4 elements: 5 5 5 5
• Output:
o There is no second largest element in the array.

Edge Cases:

1. All Elements Are the Same: If all elements are the same, there is no second largest
element.

ni
2. Single Element Array: If the array contains only one element, the program prints an
error message.

Pa
3. Negative Numbers: The solution works correctly for negative numbers as well.

Time Complexity: ra
• The time complexity of this approach is O(n), where n is the number of elements in
the array. This is because we only need to traverse the array once.
d
Space Complexity:
en

• The space complexity is O(1), since no extra arrays or data structures are used, and
only a few variables are used to track the largest and second largest elements.
ar

33. Question: How do you find the second smallest

element from an array in Java?
m

Key Concept:
A

To find the second smallest element, you can use a two-pass approach similar to finding the
second largest element. You traverse the array once to find the smallest element, then
traverse it again to find the smallest element that is greater than the first smallest.
Alternatively, you can do it in one pass by keeping track of both the smallest and second
smallest elements during a single traversal.
Approach:

1. Initialize two variables firstSmallest and secondSmallest to hold the smallest and
second smallest values, respectively.
2. Traverse the array:
o If the current element is smaller than firstSmallest, update secondSmallest to
be firstSmallest, and update firstSmallest to the current element.
o Else if the current element is greater than firstSmallest but smaller than

ni
secondSmallest, update secondSmallest.
3. After the loop, secondSmallest will hold the second smallest value in the array.

Pa
Solution: Find the Second Smallest Element in the Array

package array; ra
import java.util.Scanner;

public class SecondSmallestInArray {

d
public static void main(String[] args) {
en

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

ar

// Step 2: Input the number of elements in the array

m

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

A

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

// Step 5: Find the second smallest element

if (n < 2) {

System.out.println("Array should have at least two elements.");

} else {

ni
int firstSmallest = Integer.MAX_VALUE;

Pa
int secondSmallest = Integer.MAX_VALUE;

// Traverse the array to find the smallest and second smallest

for (int i = 0; i < n; i++) {

ra
if (arr[i] < firstSmallest) {
d
secondSmallest = firstSmallest;
en

firstSmallest = arr[i];

} else if (arr[i] > firstSmallest && arr[i] < secondSmallest) {

ar

secondSmallest = arr[i];

}
m

}
A

// Step 6: Output the second smallest element

if (secondSmallest == Integer.MAX_VALUE) {

System.out.println("There is no second smallest element in the array.");

} else {

System.out.println("The second smallest element in the array is: " +

secondSmallest);
}

// Close the scanner

scanner.close();

ni
Explanation of Steps:

Pa
1. Input Handling: The program takes input for the size of the array and its elements.
2. Finding the Second Smallest:
o We initialize firstSmallest and secondSmallest with Integer.MAX_VALUE to
ra
ensure any element in the array can replace them.
o Traverse the array:
▪ If the current element is smaller than firstSmallest, update
d
secondSmallest to the value of firstSmallest, and then set firstSmallest
en

to the current element.

▪ If the current element is greater than firstSmallest but smaller than
secondSmallest, update secondSmallest.
ar

3. Edge Cases:
o If the array has fewer than two elements, the program prints an error
m

message.
o If all elements are the same, the program will print that there is no second
A

smallest element.
4. Output: The second smallest element is printed after the traversal.

Input/Output Example:

• Input 1 (Valid Case):

o Enter the number of elements: 6
o Enter 6 elements: 10 20 20 40 5 50
 • Output:
o The second smallest element in the array is: 10
• Input 2 (No Second Smallest Case):
o Enter the number of elements: 4
o Enter 4 elements: 5 5 5 5
• Output:
o There is no second smallest element in the array.

ni
Edge Cases:

Pa
1. All Elements Are the Same: If all elements are the same, there is no second smallest
element.
2. Single Element Array: If the array contains only one element, the program prints an
ra
error message.
3. Negative Numbers: The solution works correctly for negative numbers as well.
d
Time Complexity:
en

• The time complexity of this approach is O(n), where n is the number of elements in
the array. This is because we only need to traverse the array once.
ar

Space Complexity:
m

• The space complexity is O(1), since no extra arrays or data structures are used, and
only a few variables are used to track the smallest and second smallest elements.
A

•
34. Question: How do you find all possible pairs of
elements in an array in Java?

Key Concept:

To find all pairs of elements in an array, you can use nested loops to iterate through each
element of the array and pair it with every other element. This approach ensures that every
combination of pairs is covered, without repetition (if order doesn't matter).

ni
Approach:

Pa
1. Use two loops:
o The outer loop picks one element.
o The inner loop pairs it with every other element after it.
2. Print each pair.
ra
Solution: Find All Pairs of Elepackage array;
d
import java.util.Scanner;
en

public class FindAllPairsInArray {

public static void main(String[] args) {

ar

// Step 1: Create a Scanner object to receive input

m

Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements in the array

A

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

// Step 5: Find and print all pairs

System.out.println("All pairs of elements:");

ni
for (int i = 0; i < n; i++) {

Pa
for (int j = i + 1; j < n; j++) {

System.out.println("(" + arr[i] + ", " + arr[j] + ")");

}
ra
}
d
// Close the scanner
en

scanner.close();

}
ar

Explanation of Steps:
m

1. Input Handling: The program first takes the number of elements in the array and
A

then takes the array elements as input.

2. Nested Loops to Find Pairs:
o The outer loop (i) iterates through each element of the array.
o The inner loop (j) starts from the element after the current element in the
outer loop (i + 1), forming a pair for each iteration.
o Each pair is printed in the format (arr[i], arr[j]).
3. Output: The program prints all the possible pairs.
Input/Output Example:

• Input:
o Enter the number of elements: 4
o Enter 4 elements: 1 2 3 4
• Output:

All pairs of elements:

ni
(1, 2)

(1, 3)

Pa
(1, 4)

(2, 3)
ra
(2, 4)
d
(3, 4)
en

Edge Cases:

1. Array with One Element: If the array contains only one element, no pairs can be
ar

formed, so the output will be empty.

2. Empty Array: If the array has zero elements, the program should handle this without
m

errors and print nothing.

Time Complexity:
A

• The time complexity of this approach is O(n^2), where n is the number of elements
in the array. This is because the inner loop runs n - 1 times for each iteration of the
outer loop, leading to quadratic time complexity.

Space Complexity:

• The space complexity is O(1) since no additional arrays or data structures are used,
and the pairing is done in place.
 •

35. Question: How do you find the first repeating element

in an array in Java?

Key Concept:

The task is to find the first element that repeats in the array. We need to identify the
element that appears more than once, and among all repeating elements, return the one

ni
that occurs first.

Approach:

Pa
1. Use a HashSet to keep track of elements that have been encountered.

2. Traverse the array: ra

o For each element, check if it is already in the set.

o If the element is already in the set, it's the first repeating element.
d
o If it's not in the set, add it to the set.
en

3. The first element found that is already in the set is the first repeating element.

Solution: Find the First Repeating Element in an Array Using HashSet

ar

package array;

import java.util.HashSet;
m

import java.util.Scanner;
A

public class FirstRepeatingElement {

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements in the array

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

ni
for (int i = 0; i < n; i++) {

Pa
arr[i] = scanner.nextInt(); // Input each element

// Step 5: Find the first repeating element

ra
int firstRepeating = -1;
d
HashSet<Integer> seenElements = new HashSet<>();
en

for (int i = n - 1; i >= 0; i--) {

if (seenElements.contains(arr[i])) {
ar

firstRepeating = arr[i];

} else {
m

seenElements.add(arr[i]);
A

// Step 6: Output the first repeating element

if (firstRepeating != -1) {

System.out.println("The first repeating element is: " + firstRepeating);

} else {

System.out.println("There are no repeating elements in the array.");

// Close the scanner

scanner.close();

ni
}

Pa
Explanation of Steps:

1. Input Handling: The user inputs the size of the array and its elements.

2. Using HashSet to Track Repeating Elements:

ra
o A HashSet is used to store elements that have been encountered. If an
element is found in the set, it is a repeating element.
d
o We traverse the array from right to left (i = n - 1 to i = 0) to ensure that the
en

first repeating element is captured correctly, as the last occurrence of the

repeating element is the first one encountered in reverse.
ar

3. Output the First Repeating Element: If a repeating element is found, it is printed;

otherwise, a message is displayed saying no repeating elements were found.
m

Input/Output Example:

• Input 1 (Repeating Elements Exist):

A

o Enter the number of elements: 6

o Enter 6 elements: 10 5 3 4 3 5

• Output:

o The first repeating element is: 5

• Input 2 (No Repeating Elements):

 o Enter the number of elements: 5

o Enter 5 elements: 1 2 3 4 5

• Output:

o There are no repeating elements in the array.

Edge Cases:

1. No Repeating Elements: If no elements repeat in the array, the output will indicate

ni
that no repeating elements were found.

2. All Elements are the Same: If all elements are the same, the first element will be

Pa
identified as the repeating element.

3. Empty Array: If the array is empty, the program should handle this gracefully without
errors.
ra
Time Complexity:

• The time complexity is O(n), where n is the number of elements in the array. We
d
traverse the array once and perform constant-time HashSet operations.
en

Space Complexity:

• The space complexity is O(n), since the HashSet may store all elements in the worst
ar

case.

•
m
A
36. Question: How do you find the first occurrence and last
occurrence of an element in an array in Java?

Key Concept:

To find the first and last occurrence of a given element in an array:

1. First Occurrence: Traverse the array from left to right and find the first index where
the element appears.

ni
2. Last Occurrence: Traverse the array from right to left and find the last index where
the element appears.

Pa
Approach:

1. First Occurrence: Traverse the array from the beginning and stop at the first
occurrence of the element.
ra
2. Last Occurrence: Traverse the array from the end and stop at the first occurrence of
the element in reverse order.
d
Solution: Find the First and Last Occurrence of an Element in an Array
en

package array;
ar

import java.util.Scanner;

public class FirstAndLastOccurrence {

m

public static void main(String[] args) {

A

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements in the array

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

ni
}

Pa
// Step 5: Input the element to search for

System.out.println("Enter the element to find its first and last occurrence: ");

int target = scanner.nextInt();

ra
// Initialize variables to store the first and last occurrence
d
int firstOccurrence = -1;
en

int lastOccurrence = -1;

// Step 6: Find the first occurrence

ar

for (int i = 0; i < n; i++) {

if (arr[i] == target) {
m

firstOccurrence = i;
A

break; // Stop once the first occurrence is found

// Step 7: Find the last occurrence

for (int i = n - 1; i >= 0; i--) {

if (arr[i] == target) {

lastOccurrence = i;

break; // Stop once the last occurrence is found

// Step 8: Output the first and last occurrence

ni
if (firstOccurrence != -1) {

Pa
System.out.println("First occurrence of element " + target + " is at index: " +
firstOccurrence);

System.out.println("Last occurrence of element " + target + " is at index: " +

lastOccurrence);
ra
} else {
d
System.out.println("Element " + target + " not found in the array.");
en

// Close the scanner

ar

scanner.close();

}
m

}
A

Explanation of Steps:

1. Input Handling: The program first takes the number of elements in the array and the
array elements.

2. First Occurrence:

o A for loop is used to traverse the array from left to right.

o As soon as the element is found, the index is recorded, and the loop breaks.
 3. Last Occurrence:

o Another for loop is used to traverse the array from right to left.

o As soon as the element is found, the index is recorded, and the loop breaks.

4. Output the Results: If the element is found, the first and last occurrence indices are
printed. If the element is not found, an appropriate message is displayed.

Input/Output Example:

ni
• Input:

o Enter the number of elements: 6

Pa
o Enter 6 elements: 10 20 20 40 50 20

o Enter the element to find its first and last occurrence: 20

ra
• Output:

First occurrence of element 20 is at index: 1

d
Last occurrence of element 20 is at index: 5
en

Input (Element Not Found):

• Enter the number of elements: 5

ar

• Enter 5 elements: 10 20 30 40 50

• Enter the element to find its first and last occurrence: 60

m

Output:
A

Element 60 not found in the array.

Edge Cases:

1. Element Not Found: If the element is not in the array, both first and last occurrences
will be -1, and the program will print that the element is not found.

2. Array with One Element: If the array has only one element, both first and last
occurrences will be the same index (0 if the element is found).
 3. All Elements Are the Same: If all elements are the same, both first and last
occurrences will be the first and last indices, respectively.

Time Complexity:

• The time complexity is O(n), where n is the number of elements in the array. We
traverse the array twice: once to find the first occurrence and once to find the last
occurrence.

Space Complexity:

ni
• The space complexity is O(1), as no additional arrays or data structures are used.

Pa
37. Question: How do you find the common elements in
multiple arrays in Java?
ra
Key Concept:
d
To find common elements in multiple arrays, you need to compare the elements across all
arrays and identify which elements appear in all of them.
en

Approach:

1. Use a HashSet to store the elements of the first array.

ar

2. For each of the subsequent arrays, find the intersection with the elements in the set
(i.e., only retain elements that are present in all arrays).
m

3. After processing all arrays, the set will contain only the common elements.
A

Solution: Find Common Elements from Multiple Arrays

package array;

import java.util.HashSet;

import java.util.Scanner;

import java.util.Set;
public class CommonElementsInArrays {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

// Step 1: Input the number of arrays

System.out.println("Enter the number of arrays: ");

int numArrays = scanner.nextInt();

ni
if (numArrays < 2) {

Pa
System.out.println("At least two arrays are required to find common elements.");

return;

}
ra
// Step 2: Input the first array
d
System.out.println("Enter the number of elements in the first array: ");
en

int n = scanner.nextInt();

Set<Integer> commonElements = new HashSet<>();

ar

System.out.println("Enter the elements of the first array:");

for (int i = 0; i < n; i++) {

m

commonElements.add(scanner.nextInt()); // Store elements of the first array

A

// Step 3: Process the remaining arrays and find the intersection

for (int k = 1; k < numArrays; k++) {

System.out.println("Enter the number of elements in array " + (k + 1) + ": ");

int m = scanner.nextInt();
Set<Integer> currentArray = new HashSet<>();

System.out.println("Enter the elements of array " + (k + 1) + ":");

for (int i = 0; i < m; i++) {

currentArray.add(scanner.nextInt());

// Retain only elements that are present in the current array

ni
commonElements.retainAll(currentArray);

Pa
}

// Step 4: Print the common elements

if (commonElements.isEmpty()) {
ra
System.out.println("No common elements found.");
d
} else {
en

System.out.println("Common elements across all arrays: " + commonElements);

}
ar

// Close the scanner

scanner.close();
m

}
A

Explanation of Steps:

1. Input Handling:

o First, the user specifies the number of arrays.

o The first array's elements are stored in a HashSet to track the elements that
are common.
 2. Intersection with Subsequent Arrays:

o For each subsequent array, another HashSet is used to store the elements
temporarily.

o The method retainAll() is called to retain only the elements that are common
between the current HashSet and the set of common elements.

3. Output the Result: After processing all arrays, the common elements are printed. If
no common elements are found, a message is displayed.

ni
Input/Output Example:

Pa
• Input:

o Enter the number of arrays: 3

o Enter the number of elements in the first array: 5

ra
o Enter the elements of the first array: 1 2 3 4 5

o Enter the number of elements in array 2: 4

d
o Enter the elements of array 2: 2 3 6 7
en

o Enter the number of elements in array 3: 3

o Enter the elements of array 3: 2 3 8

ar

• Output:
m

o Common elements across all arrays: [2, 3]

• Input (No Common Elements):

A

o Enter the number of arrays: 3

o Enter the number of elements in the first array: 4

o Enter the elements of the first array: 1 2 3 4

o Enter the number of elements in array 2: 4

o Enter the elements of array 2: 5 6 7 8

 o Enter the number of elements in array 3: 3

o Enter the elements of array 3: 9 10 11

• Output:

o No common elements found.

Edge Cases:

1. No Common Elements: If no common elements exist across all arrays, the program

ni
will correctly handle this and print a message saying no common elements were
found.

Pa
2. Arrays with One Element: If any array has only one element, that element must be
common to all arrays for it to appear in the result.

3. All Elements Are Common: If all elements of the arrays are the same, all elements
will appear in the result.
ra
Time Complexity:
d
• The time complexity is O(n * m), where n is the size of the largest array, and m is the
en

number of arrays. This is because we must traverse all arrays and perform set
operations.
ar

Space Complexity:

• The space complexity is O(n), where n is the size of the largest array, as we need to
m

store the common elements in a set.

A
38. Question: How do you rearrange the positive and
negative elements of an array in Java?

Key Concept:

You can rearrange the positive and negative elements in an array such that all negative
elements come before the positive elements, while maintaining their relative order. This can
be done in O(n) time by traversing the array once and using a simple approach.

ni
Approach:

1. Two-pointer technique: You can traverse the array and, when encountering a

Pa
negative element, shift the negative elements to the left side.

2. Maintain Order: To maintain the relative order of both positive and negative
numbers, you can use an auxiliary approach like insertion sort-style shifting.
ra
Solution: Rearrange Positive and Negative Elements While Maintaining Order
d
package array;
en

import java.util.Scanner;

public class RearrangePositiveNegative {

ar

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

m

Scanner scanner = new Scanner(System.in);

A

// Step 2: Input the number of elements in the array

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

// Step 5: Rearrange the array with positive and negative elements

ni
rearrangePositiveNegative(arr, n);

Pa
// Step 6: Print the rearranged array

System.out.println("Re-arranged array with negative elements first and positive

elements later:");

for (int i = 0; i < n; i++) {

ra
System.out.print(arr[i] + " ");
d
}
en

// Close the scanner

scanner.close();
ar

}
m

// Function to rearrange the array with negatives first and positives later

public static void rearrangePositiveNegative(int[] arr, int n) {

A

int j = 0; // Index to track the position for negative numbers

for (int i = 0; i < n; i++) {

if (arr[i] < 0) {

// If current element is negative, move it to the 'j' index

if (i != j) {
// Swap the elements

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

j++; // Increment index for the next negative number

ni
}

Pa
}

}
ra
Explanation of Steps:
d
1. Input Handling: The program first takes the size of the array and the array elements
as input.
en

2. Rearrange Logic:

o A variable j is used to track the position of the next negative number.

ar

o The program traverses the array, and whenever a negative element is found,
it swaps that element with the element at index j and increments j.
m

o This process ensures that all negative numbers are shifted to the left, while
A

positive numbers remain to the right.

3. Output: The rearranged array is printed, where all negative elements appear before
the positive elements.

Input/Output Example:

• Input:

o Enter the number of elements: 8

 o Enter 8 elements: -1 2 -3 4 -5 6 -7 8

• Output:

Re-arranged array with negative elements first and positive elements later:

-1 -3 -5 -7 2 4 6 8

Edge Cases:

ni
1. All Positive or All Negative Elements: If the array contains only positive or only
negative elements, the array remains unchanged.

Pa
2. Empty Array: If the array is empty (n = 0), the program should handle this gracefully.

3. One Element: If the array contains only one element, no rearrangement is needed.
ra
Time Complexity:

• The time complexity of this approach is O(n), where n is the number of elements in
d
the array, since we traverse the array only once.
en

Space Complexity:

• The space complexity is O(1), as no additional space is required apart from a few
variables.
ar

Alternative Approach: Using Two Arrays (Without Preserving Order)

m

Another approach is to create two arrays—one for positive numbers and one for negative
numbers—and then combine them. This approach does not preserve the relative order of
the numbers.
A

package array;

public class RearrangePositiveNegativeWithoutOrder {

public static void main(String[] args) {

int[] arr = {-1, 2, -3, 4, -5, 6, -7, 8};

int n = arr.length;

// Temporary arrays to hold negative and positive elements

int[] negatives = new int[n];

int[] positives = new int[n];

int negIndex = 0, posIndex = 0;

// Separate the elements into negatives and positives

ni
for (int i = 0; i < n; i++) {

Pa
if (arr[i] < 0) {

negatives[negIndex++] = arr[i];

} else {
ra
positives[posIndex++] = arr[i];
d
}
en

// Copy the negative elements back to the original array

ar

for (int i = 0; i < negIndex; i++) {

arr[i] = negatives[i];
m

}
A

// Copy the positive elements back to the original array

for (int i = 0; i < posIndex; i++) {

arr[negIndex + i] = positives[i];

// Print the rearranged array

System.out.println("Re-arranged array (order not preserved):");

for (int i = 0; i < n; i++) {

System.out.print(arr[i] + " ");

ni
Explanation:

Pa
• In this approach, we create two temporary arrays: one for negative numbers and one
for positive numbers.

• We copy the negative numbers back into the original array, followed by the positive
numbers.
ra
• This approach does not preserve the relative order of elements, and the space
d
complexity is O(n) due to the use of temporary arrays.
en

39. Question: How do you find the second smallest

ar

element in an array without sorting in Java?

Key Concept:
m

You can find the second smallest element in an array in one pass (i.e., without sorting the
array) by keeping track of both the smallest and second smallest elements during a single
A

traversal of the array.

Approach:

1. Initialize two variables, firstSmallest and secondSmallest, to hold the smallest and
second smallest values.

2. Traverse the array:

 o If the current element is smaller than firstSmallest, update secondSmallest to
be firstSmallest and update firstSmallest to the current element.

o Else if the current element is greater than firstSmallest and smaller than
secondSmallest, update secondSmallest.

3. At the end of the traversal, secondSmallest will hold the second smallest value.

Solution: Find the Second Smallest Element Without Sorting

ni
package array;

import java.util.Scanner;

Pa
public class SecondSmallestElement {

public static void main(String[] args) {

ra
// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

d
// Step 2: Input the number of elements in the array
en

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

ar

// Step 3: Create an array of the given size

m

int[] arr = new int[n];

// Step 4: Input elements into the array

A

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

// Step 5: Find the second smallest element

if (n < 2) {

System.out.println("Array should have at least two elements.");

} else {

int firstSmallest = Integer.MAX_VALUE;

int secondSmallest = Integer.MAX_VALUE;

// Traverse the array to find the smallest and second smallest

ni
for (int i = 0; i < n; i++) {

Pa
if (arr[i] < firstSmallest) {

secondSmallest = firstSmallest;

firstSmallest = arr[i];
ra
} else if (arr[i] > firstSmallest && arr[i] < secondSmallest) {
d
secondSmallest = arr[i];
en

}
ar

// Step 6: Output the second smallest element

if (secondSmallest == Integer.MAX_VALUE) {
m

System.out.println("There is no second smallest element in the array.");

A

} else {

System.out.println("The second smallest element in the array is: " +

secondSmallest);

// Close the scanner

scanner.close();

Explanation of Steps:

1. Input Handling: The user provides the size of the array and its elements.

2. Finding the Second Smallest:

ni
o We initialize firstSmallest and secondSmallest to Integer.MAX_VALUE to
ensure any element in the array can replace them.

Pa
o Traverse the array:

▪ If the current element is smaller than firstSmallest, update

ra
secondSmallest to the value of firstSmallest, and then update
firstSmallest to the current element.

▪ If the current element is greater than firstSmallest but smaller than

d
secondSmallest, update secondSmallest.
en

3. Edge Case Handling: If all elements are the same or if there is no second smallest
element, the program will notify the user that no second smallest element exists.
ar

4. Output: The second smallest element is printed at the end of the traversal.

Input/Output Example:
m

• Input 1 (Valid Case):

A

o Enter the number of elements: 6

o Enter 6 elements: 10 20 5 30 15 25

• Output:

o The second smallest element in the array is: 10

• Input 2 (No Second Smallest Case):

 o Enter the number of elements: 5

o Enter 5 elements: 5 5 5 5 5

• Output:

o There is no second smallest element in the array.

Edge Cases:

1. Array with Less Than Two Elements: If the array has fewer than two elements, the

ni
program will print an error message.

2. All Elements Are the Same: If all elements are the same, the program will print that

Pa
no second smallest element exists.

3. Negative Numbers: The program will handle negative numbers as well.

Time Complexity:
ra
• The time complexity of this approach is O(n), where n is the number of elements in
the array. This is because we only need to traverse the array once.
d
en

Space Complexity:

• The space complexity is O(1), since no additional arrays or data structures are used,
ar

and only a few variables are used to track the smallest and second smallest elements.
m

40. Question: How do you segregate an array in Java?

A

Key Concept:

Segregating an array typically refers to partitioning or separating the array based on a

condition. Common segregation tasks include:

1. Segregating positive and negative numbers.

2. Segregating even and odd numbers.

 3. Segregating 0s and 1s (for binary arrays).

We'll explore three different cases of segregation.

Case 1: Segregate Positive and Negative Numbers

In this case, we'll move all the negative numbers to the left side of the array and positive
numbers to the right side.

Solution 1: Segregate Positive and Negative Numbers

ni
package array;

Pa
import java.util.Scanner;

public class SegregatePositiveNegative {

public static void main(String[] args) {

ra
// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

d
// Step 2: Input the number of elements in the array
en

System.out.println("Enter the number of elements in the array: ");

ar

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

m

int[] arr = new int[n];

// Step 4: Input elements into the array

A

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

}
// Step 5: Segregate the array with positive and negative numbers

segregatePositiveNegative(arr, n);

// Step 6: Print the segregated array

System.out.println("Segregated array with negative numbers on the left and

positive numbers on the right:");

for (int i = 0; i < n; i++) {

ni
System.out.print(arr[i] + " ");

Pa
// Close the scanner

scanner.close();

}
ra
// Function to segregate positive and negative numbers
d
public static void segregatePositiveNegative(int[] arr, int n) {
en

int j = 0; // Index to track the position for negative numbers

for (int i = 0; i < n; i++) {

ar

if (arr[i] < 0) {
m

// Swap negative element to the 'j' index

if (i != j) {
A

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

j++; // Increment index for the next negative number

}

Input/Output Example:

• Input:

ni
o Enter the number of elements: 8

Pa
o Enter 8 elements: -1 2 -3 4 -5 6 -7 8

• Output:

Segregated array with negative numbers on the left and positive numbers on the right:
ra
-1 -3 -5 -7 2 4 6 8
d
en

Case 2: Segregate Even and Odd Numbers

ar

In this case, we'll move all the even numbers to the left side of the array and odd numbers to
the right side.
m

Solution 2: Segregate Even and Odd Numbers

A

package array;

import java.util.Scanner;

public class SegregateEvenOdd {

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements in the array

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

ni
// Step 4: Input elements into the array

Pa
System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

ra
}
d
// Step 5: Segregate the array with even and odd numbers
en

segregateEvenOdd(arr, n);

// Step 6: Print the segregated array

ar

System.out.println("Segregated array with even numbers on the left and odd numbers
on the right:");
m

for (int i = 0; i < n; i++) {

System.out.print(arr[i] + " ");

A

// Close the scanner

scanner.close();

// Function to segregate even and odd numbers

public static void segregateEvenOdd(int[] arr, int n) {

int j = 0; // Index to track the position for even numbers

for (int i = 0; i < n; i++) {

if (arr[i] % 2 == 0) {

// Swap even element to the 'j' index

if (i != j) {

ni
int temp = arr[i];

Pa
arr[i] = arr[j];

arr[j] = temp;

}
ra
j++; // Increment index for the next even number
d
}
en

}
ar

Input/Output Example:
m

• Input:
A

o Enter the number of elements: 8

o Enter 8 elements: 1 2 3 4 5 6 7 8

• Output:

Segregated array with even numbers on the left and odd numbers on the right:

24681357
Case 3: Segregate 0s and 1s (Binary Array)

In this case, we'll segregate a binary array, where all 0s are moved to the left and all 1s are
moved to the right.

Solution 3: Segregate 0s and 1s

package array;

ni
import java.util.Scanner;

public class SegregateZerosOnes {

Pa
public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

ra
Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements in the binary array

d
System.out.println("Enter the number of elements in the binary array (0s and 1s
en

only): ");

int n = scanner.nextInt(); // Size of the array

ar

// Step 3: Create an array of the given size

int[] arr = new int[n];

m

// Step 4: Input elements into the binary array (only 0s and 1s)
A

System.out.println("Enter " + n + " binary elements (0s and 1s):");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element (0 or 1)

// Step 5: Segregate the array with 0s and 1s

segregateZerosOnes(arr, n);

// Step 6: Print the segregated array

System.out.println("Segregated binary array with 0s on the left and 1s on the

right:");

for (int i = 0; i < n; i++) {

System.out.print(arr[i] + " ");

ni
}

// Close the scanner

Pa
scanner.close();

}
ra
// Function to segregate 0s and 1s in a binary array

public static void segregateZerosOnes(int[] arr, int n) {

d
int j = 0; // Index to track the position for 0s
en

for (int i = 0; i < n; i++) {

if (arr[i] == 0) {
ar

// Swap 0 to the 'j' index

m

if (i != j) {

int temp = arr[i];

A

arr[i] = arr[j];

arr[j] = temp;

j++; // Increment index for the next 0

}
}

Segregated binary array with 0s on the left and 1s on the right:

00001111

ni
Edge Cases for All Solutions:

Pa
1. Array with Only One Type of Element: If the array contains only one type of element
(all positives, all negatives, all evens, etc.), the array remains unchanged.

2. Empty Array: If the array is empty, the program should handle this gracefully and
ra
print nothing.

3. One Element Array: If the array contains only one element, no segregation is needed.
d
Time Complexity:
en

• The time complexity for all solutions is O(n), where n is the number of elements in
the array. This is because we only traverse the array once.
ar

Space Complexity:

• The space complexity is O(1), as no additional arrays or data structures are used
beyond a few variables.
m
A

41. Question: How do you remove consecutive duplicates

from an array in Java?

Key Concept:

To remove consecutive duplicates from an array, you need to traverse the array and compare
each element with the previous one. If an element is the same as the previous one, you skip
it. The goal is to retain only the first occurrence of consecutive elements.
Approach:

1. Traverse the array, compare each element with the previous one.

2. Only retain elements that are different from the previous element.

3. Create a new array or modify the original array in place to store the result without
consecutive duplicates.

Solution: Remove Consecutive Duplicates from an Array

ni
package array;

Pa
import java.util.Scanner;

public class RemoveConsecutiveDuplicates {

public static void main(String[] args) {

ra
// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

d
// Step 2: Input the number of elements in the array
en

System.out.println("Enter the number of elements in the array: ");

ar

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

m

int[] arr = new int[n];

// Step 4: Input elements into the array

A

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

}
// Step 5: Remove consecutive duplicates

int[] result = removeConsecutiveDuplicates(arr, n);

// Step 6: Print the modified array

System.out.println("Array after removing consecutive duplicates:");

for (int i = 0; i < result.length; i++) {

System.out.print(result[i] + " ");

ni
}

Pa
// Close the scanner

scanner.close();

}
ra
// Function to remove consecutive duplicates
d
public static int[] removeConsecutiveDuplicates(int[] arr, int n) {
en

if (n == 0) {

return new int[0]; // Return empty array if input array is empty

ar

// Create a temporary array to store the result without consecutive duplicates

m

int[] temp = new int[n];

A

int j = 0; // Index for the temp array

// Initialize the first element in the result array

temp[j++] = arr[0];

// Traverse the array starting from the second element

for (int i = 1; i < n; i++) {

// If the current element is not the same as the previous one, add it to the
result

if (arr[i] != arr[i - 1]) {

temp[j++] = arr[i];

ni
// Create the final result array of size j

int[] result = new int[j];

Pa
System.arraycopy(temp, 0, result, 0, j);

return result;

}
ra
}
d
Explanation of Steps:
en

1. Input Handling: The user provides the size of the array and its elements.

2. Removing Consecutive Duplicates:

ar

o A temporary array temp[] is created to store the elements without

consecutive duplicates.
m

o The first element is always added to the result.

A

o For every subsequent element, the program checks if it is the same as the
previous element. If it's not, the element is added to the result.

3. Return the Result: The result is returned as a new array that contains no consecutive
duplicates.

4. Output: The final array without consecutive duplicates is printed.

Input/Output Example:
 • Input:

o Enter the number of elements: 10

o Enter 10 elements: 1 1 2 2 2 3 4 4 5 5

• Output:

Array after removing consecutive duplicates:

12345

ni
Edge Cases:

1. Empty Array: If the array is empty, the program will return an empty array.

Pa
2. Array with One Element: If the array contains only one element, no duplicates exist,
and the array remains unchanged. ra
3. All Elements Are the Same: If all elements are the same, the result will contain only
one element.
d
en

Time Complexity:

• The time complexity of this approach is O(n), where n is the number of elements in
the array. This is because we only traverse the array once.
ar

Space Complexity:
m

• The space complexity is O(n) because we use a temporary array to store the result,
and the size of this array is proportional to the input array.
A

In-place Modification (Without Using Extra Space)

If you don't want to use extra space and want to modify the array in place, you can use the
following approach:

package array;

import java.util.Scanner;
public class RemoveConsecutiveDuplicatesInPlace {

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements in the array

System.out.println("Enter the number of elements in the array: ");

ni
int n = scanner.nextInt(); // Size of the array

Pa
// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

ra
System.out.println("Enter " + n + " elements:");
d
for (int i = 0; i < n; i++) {
en

arr[i] = scanner.nextInt(); // Input each element

}
ar

// Step 5: Remove consecutive duplicates in-place

int length = removeConsecutiveDuplicatesInPlace(arr, n);

m

// Step 6: Print the modified array

A

System.out.println("Array after removing consecutive duplicates:");

for (int i = 0; i < length; i++) {

System.out.print(arr[i] + " ");

// Close the scanner

scanner.close();

// Function to remove consecutive duplicates in place

public static int removeConsecutiveDuplicatesInPlace(int[] arr, int n) {

if (n == 0) {

return 0; // Return 0 if the array is empty

ni
}

Pa
int j = 0; // Index for the modified array

// Traverse the array

for (int i = 1; i < n; i++) {

ra
if (arr[j] != arr[i]) {
d
j++;
en

arr[j] = arr[i]; // Place non-duplicate element at index j

}
ar

// The new length of the array without consecutive duplicates

m

return j + 1;
A

Solution:

• We use a single index j to track the position where the next unique element should
be placed.
 • As we traverse the array, we compare each element with the element at index j. If
they are different, we increment j and update arr[j] to the current element.

• The function returns the new length of the array after removing consecutive
duplicates.

Input/Output Example (In-Place):

• Input:

Enter the number of elements: 10

ni
o

o Enter 10 elements: 1 1 2 2 2 3 4 4 5 5

Pa
• Output:

Array after removing consecutive duplicates:

12345
d ra
en

Time Complexity (In-Place):

ar

• The time complexity is O(n), where n is the number of elements in the array.

Space Complexity (In-Place):

m

• The space complexity is O(1) since we are modifying the array in place without using
any additional arrays.
A
42. Question: How do you count all possible pairs from an
array in Java?

Key Concept:

To count all possible pairs from an array, you can use a nested loop. Each element of the
array will be paired with every other element that comes after it in the array. If there are n
elements in the array, the total number of possible pairs can be calculated as:

ni
• Total pairs = n * (n - 1) / 2

Approach:

Pa
1. Nested Loops:

o The outer loop selects one element of the array.

ra
o The inner loop pairs that element with all subsequent elements.

2. Count the Pairs: Each time a valid pair is found, increment the count.
d
Solution: Count All Possible Pairs in an Array
en

package array;

import java.util.Scanner;
ar

public class CountAllPairs {

m

public static void main(String[] args) {

// Step 1: Create a Scanner object to receive input

A

Scanner scanner = new Scanner(System.in);

// Step 2: Input the number of elements in the array

System.out.println("Enter the number of elements in the array: ");

int n = scanner.nextInt(); // Size of the array

// Step 3: Create an array of the given size

int[] arr = new int[n];

// Step 4: Input elements into the array

System.out.println("Enter " + n + " elements:");

for (int i = 0; i < n; i++) {

arr[i] = scanner.nextInt(); // Input each element

ni
// Step 5: Count and print all possible pairs

Pa
int totalPairs = countPairs(arr, n);

System.out.println("Total number of pairs: " + totalPairs);

// Close the scanner

ra
scanner.close();
d
}
en

// Function to count all possible pairs

public static int countPairs(int[] arr, int n) {

ar

int pairCount = 0;

// Nested loop to generate all pairs

m

for (int i = 0; i < n; i++) {

A

for (int j = i + 1; j < n; j++) {

// Each pair (arr[i], arr[j]) is valid, so count it

pairCount++;

}
return pairCount;

Explanation of Steps:

1. Input Handling: The program first takes the size of the array and the array elements
as input.

ni
2. Counting the Pairs:

o The outer loop iterates over each element in the array.

Pa
o The inner loop generates a pair between the current element in the outer
loop and each subsequent element in the array.
ra
o For each valid pair, the pairCount is incremented.

3. Return the Count: After generating all possible pairs, the function returns the total
count of pairs.
d
4. Output: The total number of possible pairs is printed.
en

Input/Output Example:
ar

• Input:

o Enter the number of elements: 4

m

o Enter 4 elements: 1 2 3 4

• Output:
A

Total number of pairs: 6

Explanation of Pairs:

For the input {1, 2, 3, 4}, the possible pairs are:

• (1, 2)
 • (1, 3)

• (1, 4)

• (2, 3)

• (2, 4)

• (3, 4)

So the total number of pairs is 6.

ni
Formula for Counting Pairs:

For an array with n elements, the number of unique pairs (without repetition) can be

Pa
calculated using the combination formula:

• Number of pairs = n * (n - 1) / 2 ra
For example, if n = 4:

• Number of pairs = 4 * (4 - 1) / 2 = 4 * 3 / 2 = 6
d
Edge Cases:
en

1. Empty Array: If the array is empty (n = 0), the number of pairs will be 0.

2. Array with One Element: If the array has only one element, no pairs can be formed,
ar

so the number of pairs will be 0.

3. Array with Two Elements: The only possible pair is (arr[0], arr[1]), so the number of
m

pairs will be 1.

Time Complexity:
A

• The time complexity of this approach is O(n^2), where n is the number of elements
in the array. This is because we use a nested loop to generate all pairs.

Space Complexity:

• The space complexity is O(1), as no additional arrays or data structures are used
beyond a few variables.