In this **Closest Numbers **HackerRank solution, Sorting is useful as the first step in many different tasks. The most common task is to make finding things easier, but there are other uses as well. In this case, it will make it easier to determine which pair or pairs of elements have the smallest absolute difference between them.

**Example**

Sorted, . Several pairs have the minimum difference of : . Return the array .

**Note**

As shown in the example, pairs may overlap.

Given a list of unsorted integers, , find the pair of elements that have the smallest absolute difference between them. If there are multiple pairs, find them all.

**Function Description**

Complete the *closestNumbers* function in the editor below.

closestNumbers has the following parameter(s):

*int arr[n]:*an array of integers

**Returns**

– *int[]:* an array of integers as described

**Input Format**

The first line contains a single integer , the length of .

The second line contains space-separated integers, .

**Constraints**

- All are unique in .

**Output Format**

**Sample Input 0**

```
10
-20 -3916237 -357920 -3620601 7374819 -7330761 30 6246457 -6461594 266854
```

**Sample Output 0**

```
-20 30
```

**Explanation 0**

*(30) – (-20) = 50*, which is the smallest difference.

**Sample Input 1**

```
12
-20 -3916237 -357920 -3620601 7374819 -7330761 30 6246457 -6461594 266854 -520 -470
```

**Sample Output 1**

```
-520 -470 -20 30
```

**Explanation 1**

*(-470) – (-520) = 30 – (-20) = 50*, which is the smallest difference.

**Sample Input 2**

```
4
5 4 3 2
```

**Sample Output 2**

```
2 3 3 4 4 5
```

**Explanation 2**

Here, the minimum difference is *1*. Valid pairs are *(2, 3)*, *(3, 4)*, and *(4, 5)*.

## Closest Numbers HackerRank Solution

I will Provide solution in Multiple programming languages for you. If you are not able to find the code in required language then please share in comments so that our team can help you.

### Problem Solution in C++

```
vector<int> closestNumbers(vector<int> arr) {
vector<int> array;
sort(arr.begin(),arr.end());
int min = INT_MAX;
for (int i = 1; i < arr.size(); i++) {
int diff = arr[i] - arr[i-1];
if (min > diff) {
min = diff;
}
}
cout<<"the value min is : "<<min<< endl;
for (int i = 1; i < arr.size(); i++) {
if (arr[i] - arr[i - 1] == min) {
array.push_back(arr[i - 1]);
array.push_back(arr[i]);
}
}
return array;
}
```

### Problem Solution in JavaScript

```
function closestNumbers(arr) {
// Write your code here
arr.sort((a, b) => a - b);
let diff = arr[1] - arr[0];
let result = [arr[0], arr[1]];
for (let i = 1; i < arr.length - 1; i++) {
if (arr[i + 1] - arr[i] < diff) {
result = [arr[i], arr[i + 1]];
diff = arr[i + 1] - arr[i];
} else if (arr[i + 1] - arr[i] === diff) {
result = [...result, arr[i], arr[i + 1]];
}
}
return result;
}
```

### Problem Solution in Python

```
def closestNumbers(arr):
ua = list(set(arr))
ua.sort()
diff = {}
for i in range(len(ua)):
if i+1 < len(ua):
diff[(ua[i],ua[i+1])] = ua[i+1]-ua[i]
resList = []
tar = min(diff.values())
for i, j in diff.items():
if j == tar:
resList.extend(i)
return resList
```

## Leave a Reply