<p>Given an array of integers <code>nums</code> and an integer <code>k</code>, return <em>the number of <b>unique</b> k-diff pairs in the array</em>.</p>

<p>A <strong>k-diff</strong> pair is an integer pair <code>(nums[i], nums[j])</code>, where the following are true:</p>

<ul>
	<li><code>0 &lt;= i, j &lt; nums.length</code></li>
	<li><code>i != j</code></li>
	<li><code>|nums[i] - nums[j]| == k</code></li>
</ul>

<p><strong>Notice</strong> that <code>|val|</code> denotes the absolute value of <code>val</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [3,1,4,1,5], k = 2
<strong>Output:</strong> 2
<strong>Explanation:</strong> There are two 2-diff pairs in the array, (1, 3) and (3, 5).
Although we have two 1s in the input, we should only return the number of <strong>unique</strong> pairs.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,2,3,4,5], k = 1
<strong>Output:</strong> 4
<strong>Explanation:</strong> There are four 1-diff pairs in the array, (1, 2), (2, 3), (3, 4) and (4, 5).
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,3,1,5,4], k = 0
<strong>Output:</strong> 1
<strong>Explanation:</strong> There is one 0-diff pair in the array, (1, 1).
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
	<li><code>-10<sup>7</sup> &lt;= nums[i] &lt;= 10<sup>7</sup></code></li>
	<li><code>0 &lt;= k &lt;= 10<sup>7</sup></code></li>
</ul>

class Solution {
public:
     
    int twoPointerApp(vector<int> &nums, int k ){
        // step 01: sort the array
        sort(nums.begin(), nums.end());
        int i = 0;
        int j = 1;
        set<pair<int, int>>ans;

        // step 02: use two pointers and compare

        while(j<nums.size()){
            if(nums[j] - nums[i] == k){
                ans.insert({nums[i], nums[j]});
                i++;
                j++;
            }
            else if(nums[j] - nums[i] > k){
                i++;
            }
            else{
                j++;
            }
            if(i == j) j++;
        } 

        return ans.size();
    }

    int binarySearchApp(vector<int> &nums, int start, int k){
        int end = nums.size() -1;
        int mid = start + (end-start)/2;

        while(start <= end){
            if(nums[mid] == k){
                return mid;
            }
            else if(nums[mid] > k){
                end = mid - 1;
            }
            else{
                start = mid + 1;
            }
            mid = start + (end - start)/2;
        }
        return -1;

    }
    int findPairs(vector<int>& nums, int k) {

        int twoPointerAns = twoPointerApp(nums, k);
        // return twoPointerAns;


        set<pair<int,int>>binarySearchAns;

        for(int i = 0; i< nums.size(); i++){
            if((binarySearchApp(nums, i+1, nums[i] + k)) != -1){
                binarySearchAns.insert({nums[i] , nums[i] + k});
            }
        }
        return binarySearchAns.size();
        
    }
};
18100