The Two Sneaky Numbers of Digitville

The most straightforward, yet least efficient, way to solve this problem is by using a brute-force approach. We can compare every number in the array with every other number to find pairs that are identical. This involves using two nested loops.

• Initialize an empty Set called duplicates to store the results and avoid adding the same number twice.
• Use a nested loop structure. The outer loop iterates from i = 0 to nums.length - 1.
• The inner loop iterates from j = i + 1 to nums.length - 1.
• Inside the inner loop, compare nums[i] and nums[j].
• If nums[i] == nums[j], it signifies a duplicate. Add nums[i] to the duplicates set.
• After the loops complete, convert the duplicates set into an array and return it.

In this method, we take each element of the array and scan the rest of the array to see if a duplicate of that element exists. We use a Set to store the found duplicates, which conveniently handles the issue of finding the same duplicate pair multiple times. For example, in [1, 1, 1], comparing the first and second 1s finds a duplicate, and comparing the first and third 1s finds the same duplicate. The set ensures we only store 1 once.

import java.util.HashSet;
import java.util.Set;

class Solution {
    public int[] findTwoSneakyNumbers(int[] nums) {
        Set<Integer> duplicates = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] == nums[j]) {
                    duplicates.add(nums[i]);
                }
            }
        }
        
        int[] result = new int[duplicates.size()];
        int index = 0;
        for (int num : duplicates) {
            result[index++] = num;
        }
        return result;
    }
}