# Solving Leetcode Interviews in Seconds with AI: Count Number of Pairs With Absolute Difference K


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2006" 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 an integer array nums and an integer k, return the number of pairs (i, j) where i < j such that |nums[i] - nums[j]| == k. The value of |x| is defined as:  x if x >= 0. -x if x < 0.    Example 1:  Input: nums = [1,2,2,1], k = 1 Output: 4 Explanation: The pairs with an absolute difference of 1 are: - [1,2,2,1] - [1,2,2,1] - [1,2,2,1] - [1,2,2,1]  Example 2:  Input: nums = [1,3], k = 3 Output: 0 Explanation: There are no pairs with an absolute difference of 3.  Example 3:  Input: nums = [3,2,1,5,4], k = 2 Output: 3 Explanation: The pairs with an absolute difference of 2 are: - [3,2,1,5,4] - [3,2,1,5,4] - [3,2,1,5,4]    Constraints:  1 <= nums.length <= 200 1 <= nums[i] <= 100 1 <= k <= 99  

	# Explanation
	*   The core idea is to iterate through the array and, for each element `nums[i]`, count the number of elements `nums[j]` (where `j > i`) such that the absolute difference between `nums[i]` and `nums[j]` is equal to `k`.
*   To optimize this, we can use a hash map (or in this case, since the constraints limit values from 1-100, a simple array/list) to store the frequency of each number encountered so far. This lets us quickly check how many numbers exist such that `nums[j] = nums[i] + k` or `nums[j] = nums[i] - k`.
*   Iterate through the array. For each element, instead of comparing to the rest of the array, we will use the frequency array to determine the number of valid pairs.

*   **Runtime Complexity:** O(n), where n is the length of the input array `nums`.  **Storage Complexity:** O(1), because the frequency array's size is bounded by the constant range of possible values (1-100 inclusive).

	
	# Code
	```python
	def countKDifference(nums: list[int], k: int) -> int:
    """
    Given an integer array nums and an integer k, return the number of pairs (i, j)
    where i < j such that |nums[i] - nums[j]| == k.
    """
    count = 0
    freq = [0] * 101  # Initialize frequency array for numbers from 1 to 100

    for num in nums:
        count += (freq[num + k] if num + k <= 100 else 0) + (freq[num - k] if num - k >= 1 else 0)
        freq[num] += 1

    return count
	```