New update is available. Click here to update.
Last Updated: 12 Jan, 2021
##### Check Difference
Easy
Problem statement

#### You are given an array 'ARR' of 'N' integers and a non-negative integer 'K'. Your task is to find if there exists two indices 'i' and 'j' such that ARR[i]-ARR[j] = K, given 'i' is not equal to 'j'. If there exist such indices you have to return TRUE else you have to return FALSE. According to the return value, βYESβ or βNOβ will be printed, βYESβ for TRUE and βNOβ for FALSE.

##### For example :
``````1. ARR = [5,3,7,1] and K=2
We can see for i=1 and j =2, ARR[i]-ARR[j] = 2 .
So we will return TRUE.
2. ARR = [-2,7,3,1,5] and K=10
We can see for any two indices it is not possible that the difference in their value is equal to K.
So we will return FALSE.
``````
##### Input Format:
``````The first line of input contains a single integer 'T', representing the number of test cases.
Then the 'T' test cases follow.

The first line of each test case contains a number 'N' denoting the size of the array.
The second line contains 'N' space-separated distinct integers a1,βa2,β...,βaN β the array elements.
``````
##### Output format:
``````For each test case print βYESβ if there exists a pair of indices with difference 'K' else return βNOβ.

The output of every test case will be printed in a separate line.
``````
##### Note :
``````You donβt have to print anything, it has already been taken care of. Just implement the given function.
``````
##### Constraints
``````1<= T <=100
1 <= N <= 10^5
-10^5 <= ARR[i] <= 10^5

Where 'T' denotes the number of test cases, 'N' denotes the number of elements in the array βARRβ respectively, and 'ARR[i]' denotes the 'i-th' element of the array 'ARR'.

Time limit: 1 second
``````
Approaches

## 01Approach

The idea is to check the difference of all possible pairs or we can say for a given i we will check all possible values of j. More formally we can run two nested loops where outer loops will iterate over i and inner loop will iterate over j.

1. Iterate over ARR[i] for each 0 <= i < N and do:
1. Iterate over ARR[j] for each i+1 <= j < N and do:
1. If (ARR[i] - ARR[j]) or (ARR[j]-ARR[i]) is equal to K then return βYESβ and stop iterating.
2. Return βNOβ if we have completed the iteration as we still have not found suitable i and j.