# Solving Leetcode Interviews in Seconds with AI: Count Pairs With XOR in a Range


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1803" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given a (0-indexed) integer array nums and two integers low and high, return the number of nice pairs. A nice pair is a pair (i, j) where 0 <= i < j < nums.length and low <= (nums[i] XOR nums[j]) <= high.   Example 1: 
 Input: nums = [1,4,2,7], low = 2, high = 6
 Output: 6
 Explanation: All nice pairs (i, j) are as follows:
     - (0, 1): nums[0] XOR nums[1] = 5 
     - (0, 2): nums[0] XOR nums[2] = 3
     - (0, 3): nums[0] XOR nums[3] = 6
     - (1, 2): nums[1] XOR nums[2] = 6
     - (1, 3): nums[1] XOR nums[3] = 3
     - (2, 3): nums[2] XOR nums[3] = 5
  Example 2: 
 Input: nums = [9,8,4,2,1], low = 5, high = 14
 Output: 8
 Explanation: All nice pairs (i, j) are as follows:
 ​​​​​    - (0, 2): nums[0] XOR nums[2] = 13
     - (0, 3): nums[0] XOR nums[3] = 11
     - (0, 4): nums[0] XOR nums[4] = 8
     - (1, 2): nums[1] XOR nums[2] = 12
     - (1, 3): nums[1] XOR nums[3] = 10
     - (1, 4): nums[1] XOR nums[4] = 9
     - (2, 3): nums[2] XOR nums[3] = 6
     - (2, 4): nums[2] XOR nums[4] = 5   Constraints:  1 <= nums.length <= 2 * 104 1 <= nums[i] <= 2 * 104 1 <= low <= high <= 2 * 104 

	# Explanation
	*   **Count Pairs within Range:** The core idea is to iterate through all possible pairs (i, j) where i < j and count the pairs whose XOR value falls within the specified range [low, high].
*   **Direct Computation:** Instead of complex data structures, we directly compute the XOR for each pair and check if it lies within the given range.
*   **Optimization:** No specific optimizations are used to keep the solution concise and understandable, given the problem constraints.

*   **Runtime Complexity:** O(n^2), where n is the length of the input array `nums`. **Storage Complexity:** O(1).

	
	# Code
	```python
	def countNicePairs(nums, low, high):
    """
    Counts the number of "nice pairs" in the given array.

    Args:
        nums: A list of integers.
        low: The lower bound of the XOR value.
        high: The upper bound of the XOR value.

    Returns:
        The number of nice pairs.
    """

    count = 0
    n = len(nums)

    for i in range(n):
        for j in range(i + 1, n):
            xor_val = nums[i] ^ nums[j]
            if low <= xor_val <= high:
                count += 1

    return count
	```