Check If N and Its Double Exist

class Solution {
public:
    bool hasPairWithDouble(vector<int>& nums) {
        unordered_map<int, int> countMap;

        // Populate counts of each number
        for (int value : nums) {
            countMap[value]++;
        }

        for (int value : nums) {
            // Check if there's a double of the current element
            if (value != 0 && countMap.find(value * 2) != countMap.end()) {
                return true;
            }
            // Special case for zero to have two occurrences
            if (value == 0 && countMap[value] > 1) {
                return true;
            }
        }
        return false;
    }
};

The provided C++ solution aims to determine if there exists a pair of elements in an integer array where one element is double the value of another.

• Initialize an unordered_map to count occurrences of each element in the array.
• Iterate through the array to populate this map with counts.
• Iterate through the array again and perform two checks for every number:
  • If the number is not zero, check if its double exists in the map.
  • If the number is zero, check if it appears at least twice (since zero doubled is still zero).

This method ensures that you effectively identify any pair where one number is twice as large as its counterpart. Using a hash map allows for constant time complexity look-up operations, making the check efficient even for larger arrays. If either condition is satisfied during the loop, the function returns true, otherwise it completes its iteration and returns false, indicating no such pair exists.

class Solution {

    public boolean checkDoubleExists(int[] elements) {
        Map<Integer, Integer> occurrences = new HashMap<>();

        for (int element : elements) {
            occurrences.put(element, occurrences.getOrDefault(element, 0) + 1);
        }

        for (int element : elements) {
            if (element != 0 && occurrences.containsKey(element * 2)) {
                return true;
            }
            if (element == 0 && occurrences.get(element) > 1) {
                return true;
            }
        }
        return false;
    }
}

This Java solution checks if any integer N in the given array and its double 2N exist within the same array. The key steps of the method checkDoubleExists in the Solution class follow:

• Create a map occurrences to store each integer from the array as a key and its frequency as a value.
• Iterate through the array, updating the occurrences map with each element's frequency.
• Re-iterate through the array. During each iteration:
  • If the current element is not zero and the map contains the key element * 2, return true.
  • If the current element is zero and its frequency in the map is greater than one, return true.
• If no such pair (N, 2N) is found after evaluating all elements, return false.

This approach efficiently identifies the presence of an element and its double by leveraging a hashmap to store and retrieve element frequencies quickly. The solution ensures all cases, including the zero-double condition, are correctly handled.

class Solution:
    def checkIfExists(self, numbers: List[int]) -> bool:
        number_map = {}

        # Record each number's occurrences in the list
        for value in numbers:
            number_map[value] = number_map.get(value, 0) + 1

        for value in numbers:
            # Check for a value's double
            if value != 0 and 2 * value in number_map:
                return True
            # Special check for zero (must be more than one zero)
            if value == 0 and number_map[value] > 1:
                return True

        return False

This Python solution addresses the problem of checking whether an array called numbers contains a number N for which 2*N (its double) also exists in the array, with a special condition for the number zero.

The approach utilizes a dictionary number_map to store the frequency of each element as the program iterates through the list. Here's how the solution is structured:

1. Initialize an empty dictionary number_map.

2. Loop through each number in numbers:

   • Update number_map with the count of each number using a standard map-get pattern, where the default is zero if the number does not exist.

3. Loop through the numbers again to check for the problem condition:

   • If the current number is not zero and there exists a double of this number in the dictionary (2 * value), return True.
   • Check specifically for zero: if the count of zero in number_map is greater than one, meaning there is more than one zero, return True.

4. If no such pair (N and 2*N, or two zeros) is found by the end of the loop, return False.

This method efficiently checks the necessary condition by leveraging dictionary lookups, which are on average O(1) in time complexity, ensuring that the solution remains efficient even for large lists.