Top 5 Array Interview Problems in Java (With Real-World Solutions)

Problem #1: Find the First Repeating Element in an Array

🧠 Problem Statement

Given:
An array of integers.

Task:
Find the first element that repeats. The second occurrence should be the earliest among all repeating elements.

Return:
The repeating element. If none exists, return -1.

🧾 Sample Input/Output

Input:
int[] arr = {10, 5, 3, 4, 3, 5, 6};
Output:
5
Explanation:
Both 5 and 3 repeat, but 5 repeats first in the array.

🔍 Naive Brute-Force Approach

Compare every element with every other element that comes after it.

public static int firstRepeatingNaive(int[] arr) {

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

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

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

                return arr[i];

            }

        }

    }

    return -1;

}

⛔ Time Complexity: O(n²)
⛔ Space Complexity: O(1)

✅ Works, but too slow for large arrays.

⚡ Optimized Approach Using HashSet

Track seen elements using a Set while traversing the array in reverse.

import java.util.*;

public class RepeatingElement {

    public static int firstRepeatingElement(int[] arr) {

        Set<Integer> seen = new HashSet<>();

        int result = -1;

        for (int i = arr.length - 1; i >= 0; i--) {

            if (seen.contains(arr[i])) {

                result = arr[i]; // This is the earliest repeated from right

            } else {

                seen.add(arr[i]);

            }

        }

        return result;

    }

    public static void main(String[] args) {

        int[] arr = {10, 5, 3, 4, 3, 5, 6};

        System.out.println(firstRepeatingElement(arr)); // Output: 5

    }

}

✅ Why Reverse Loop?

Because it ensures we find the first repeating element (in original order) — the earliest second occurrence.

🧠 Edge Cases

📈 Time & Space Complexity

🧨 Interview Variants

1. "Return the index of first repeating element"
   👉 Track both value and index using Map<Integer, Integer>
2. "Return all repeating elements"
   👉 Use Map<Integer, Integer> to count frequency
3. "In-place solution?"
   👉 Only if values are in known limited range (e.g. 1 ≤ arr[i] ≤ n)

✅ Recap: Key Takeaways

• Use Set to detect duplicates efficiently
• Reverse traversal gives correct repeat order
• Watch out for multiple correct-looking repeats
• O(n²) brute-force may pass small test cases — not optimal for large data