Yeah, it was pretty easy after reading your comment.

n,a = input(),sorted(map(int, input().split()))
print(min(abs(x-y) for x,y in zip(a,a[1:])))

Here is your approach in C++:

#include <numeric>
#include <iterator>
using namespace std;
typedef long long ll;

int main() {
    ll iNum; cin >> iNum;
    vector<ll> iVec, sortVec;
    copy_n(istream_iterator<ll>(cin), iNum, back_inserter(iVec));
    sort(begin(iVec),end(iVec));
    adjacent_difference(begin(iVec),end(iVec),
    back_inserter(sortVec));
    cout << *min_element(begin(sortVec)+1,end(sortVec));
    return 0;
}

Why should we consider only consecutive pairs? It can be any two elements from the array right?

//Same approch in C++ using vector int main() { /* Enter your code here. Read input from STDIN. Print output to STDOUT */
int n; cin>>n; vector vec(n); generate(vec.begin(), vec.end(), []{int x; cin>>x; return x;}); sort(vec.begin(), vec.end());

int diff = abs(vec[0] - vec[1]);
int sub;
for(int i=0; i<(n-1); i++){
        sub = abs(vec[i] - vec[i+1]);
    if(sub < diff)
        diff = sub;
}
cout<<diff;

return 0;

}

C++ STL

int minimumAbsoluteDifference(vector<int> arr) {
    sort(begin(arr), end(arr));
    adjacent_difference(begin(arr), 
                        end(arr),
                        begin(arr),
                        [](int a, int b){
                            return abs(a-b);
                        });
    return *min_element(begin(arr)+1, end(arr));
}

Why do you sort it? In what way does it help?

with your approach i am able to pass only 2 test cases, but with my code i am unable to pass only 4th test case,Suggest some changes or another approach. Here is my code in C:

#include<stdio.h>
#include<stdlib.h>
main()
{
    long int i,j,n;
    scanf("%ld",&n);
    long long int min,a[n];
    scanf("%lld%lld",&a[0],&a[1]);
    min=abs(a[0]-a[1]);
    for(i=2;i<n;i++)
    {
        scanf("%lld",&a[i]);
        for(j=0;j<i;j++)
        {
            if(abs(a[j]-a[i])<min)
                min=abs(a[j]-a[i]);
            if(min==0)
            {
                break;
            }
        }
        if(min==0)
            break;
    }
    printf("%lld",min);
}

Yup. Of course then we get an Theta nlogn. However this may be the best we can do for this problem

hiiiiiiiiiiiiii

thanks!

Same solution in Javascript

function minimumAbsoluteDifference(n, arr) {
    arr.sort((a, b) => a - b);
    
    let min = Math.abs(arr[0] - arr[1]), diff;
    
    for(let i = 2; i < n; i++) {
        diff = Math.abs(arr[i] - arr[i-1]);
        if(diff < min) {
            min = diff;
        }
    }
    
    return min;
}

Yes...This solution works. My concern is that does it ensure that minimum difference between sorted vector is possible combination as per example output case?

Great hint, haven't thought about that. I try to keep in mind that sorted Arrays have certain characteristics.

How i solve time limites..?

which sort is best? insertion?

I love your idea!!! You made the question so easy!

this was really helpful.

Thanks, It was really helpful.. do u think using these hints is cheating ?

can we get maximum difference from this method?

A little diffrent C++ approch

#include <cmath>
#include <limits>
#include <set>
#include <iostream>
#include <algorithm>
#include <iterator>

using int64 = long long int;

template<typename Iterator>
constexpr auto getResult(
	      Iterator begin,
	const Iterator end)-> int64
{
	// following is not working with GCC 
	//using Type = typename std::decay<typename std::iterator_traits<Iterator>::difference_type>::type;
	//static_assert(std::is_same<Type, int64>::value, "wrong types"); // to make sure
	using Type = int64;
	Type ans{ std::numeric_limits<Type>::max() };

	for (auto iter = std::next(begin); iter != end; ++iter)
	{
		ans = std::min(ans, std::abs(*iter - *std::prev(iter)));
	}
	return ans;
}

int main()
{
	std::ios_base::sync_with_stdio(0);   std::cin.tie(0);   std::cout.tie(0);

	int64 n{};
	std::cin >> n;

	std::multiset<int64> mySet;
	while (n--)
	{
		int64 temp{}; std::cin >> temp;
		mySet.insert(temp);
	}
	std::cout << ::getResult(mySet.begin(), mySet.end()) << std::endl;
	return 0;
}

C# Code

static int minimumAbsoluteDifference(int[] arr) {
        int n = arr.Length;

        Array.Sort(arr);

        int minAbsDiff = Math.Abs(arr[0] - arr[1]);

        for(int i = 1; i < n - 1; i++){
            int tempDiff = Math.Abs(arr[i] - arr[i + 1]);
            if(tempDiff < minAbsDiff)
                minAbsDiff = tempDiff;
        }
        return minAbsDiff;
    }
		

thanks

No need in 2).

Min should always default to max.

In this example: int min = INT_MAX;

Then compare abs of all consecutive pairs to min.

Thanks your guidence lead to Better solution !!

public class Solution {

// Complete the minimumAbsoluteDifference function below.
static int minimumAbsoluteDifference(int[] arr) {

    Arrays.sort(arr);
    int min = Math.abs(arr[0] - arr [1]);
    for(int i = 1 ; i < arr.length-1 ; i++){
        if(Math.abs(arr[i] - arr[i+1]) < min)
             min = Math.abs(arr[i] - arr[i+1]);
    }

return min;
}

Javascript solution:

function minimumAbsoluteDifference(arr) {

// sort array
arr.sort((a, b) => a - b)

// consider a min
let min = Math.abs(arr[0] - arr[1])

for(let i = 1; i < arr.length - 1; i++) {

    // calculate absolute between absolutes
    // minimum difference is between adjacent elements in a sorted array
    let m = Math.abs(arr[i] - arr[i+1])
    if(m < min) {
       min = m
    }
}

return min

}

Probably because if you locate some local minimum distance, that's also the global minimum until you find something better. In other words, if you find a minimum, that's optimal and you take it. In contrast, finding a shortest route in a graph doesn't work if you greedily always take the shortest route at every juncture, since sometimes taking a longer route in the short term offers a better path overall.

I was wondering the same. This requires the array to be sorted, which obviously leads to the complexity of O(n log n). I wonder if we can solve it by using other data structures (thus increasing the space complexity)

Can't stop thinking the same. Well, actually we can sort the array in linear time using count sort (linear in terms of the range of elements in the array) and have a linear running time algorithm but it's not really elegant since we increase space complexity.

This should do it without sorting. It is O(cn) for time and O(n) for space.

BUT, it times out on the last two input sets since the array values are very large(-10^9 < a < 10^9), while n < 10^5. This yields a constant that is larger than n.

If you have a domain with a much smaller range for a, it would make sense.

def minimumAbsoluteDifference2(n, arr):
    min_abs = abs(arr[0] - arr[1])
    s = set(arr[:2])
    for x in arr[2:]:
        for d in range(1, min_abs):
            if x + d in s or x - d in s:
                min_abs = d
                break
        s.add(x)
    return min_abs

For others reading this solution I just want to comment on using arr.sort() in JS since this has burned me before.

By default, Javascript's Array.prototype.sort will sort elements in lexicographical order, which means sorting [2, 4, 30] will convert the integers to strings and produce [2, 30, 4] (since '3' comes before '4'). To properly sort integers a custom compare function should be passed in. I.e. arr.sort( ( a, b ) => a - b ).

The default sort order is built upon converting the elements into strings, then comparing their sequences of UTF-16 code units values.

MDN Reference

Somehow none of the test cases triggered this exact scenario and the posted solution indeed passes all tests, but feel free to experiment with various inputs on your own, e.g. [2, 4, 30] (should return 2, but would return 26 using the default sort).

Thank you for sharing - I was thinking along the same lines. Is there any reason why you chose 2 billion as your upper bound for the difference? Why not math.inf?

I did basically your solution but in a more beginner friendly, readable way.

# Complete the minimumAbsoluteDifference function below.
def minimumAbsoluteDifference(arr):
    min_abs_diff = sys.maxsize
    tmp_result = 0
    arr.sort()
    for i in range (len(arr) - 1):
        tmp_result = abs(arr[i] - arr[i + 1])
        if tmp_result < min_abs_diff:
            min_abs_diff = tmp_result
    return min_abs_diff

I feel like using the sort(...) function is like cheating. Oh well.