使用javascript查找数组中任意两对元素之间的最小绝对差异时出错

Question

I am trying to solve a program for finding minimum absolute difference between any pair of elements in an array using javascript. The input takes arguments as array elements. The output returns the minimum absolute difference between any two elements in an array

For example, input as [1,2,4] and the output is 1

The detailed description of the problem is given in this link.

In my code, when giving input array containing 1000 elements, it compiles and shows Terminated due to time out, but it works for smaller sized input arrays

I think the error comes from the issues in performance and complexity . I researched for issue but I'm stuck with how to proceed further steps

My code:

  var arr = [..] //array containing 1000 elements var count = minimumAbsoluteDifference(arr); console.log(count); function minimumAbsoluteDifference(arr) { var diff = []; var index = 0; arr.sort((a, b) => { return (a - b); }); for (var i = 0; i < arr.length-1; i++){ for (var j = i+1; j < arr.length; j++){ if (i != j) { diff[index] = Math.abs(arr[i] - arr[j]); console.log("index", i, j); index++; } } } var minAbsoluteDifference = Math.min(...diff); return minAbsoluteDifference; } 

Answer 1

After the array has been sorted, the minimum absolute difference between any two elements will necessarily be between two adjacent elements. So, you can change your nested for loops ( O(N^2) ) to a single for loop ( O(N) ) (though, the sort function is still O(N log N) , so overall complexity is only reduced to O(N log N) ):

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

This would work in most situations, but another issue is that HackerRank appears to call this function with unreasonably huge arrays (eg, with 100000 items in a single array), so

Math.min(...diff)

will result in

RangeError: Maximum call stack size exceeded

Call Math.min on every iteration instead:

function minimumAbsoluteDifference(arr) {
    var lowestDiff = Infinity;
    arr.sort((a, b) => a - b);
    for (var i = 0; i < arr.length - 1; i++) {
        lowestDiff = Math.min(lowestDiff, Math.abs(arr[i] - arr[i + 1]));
    }
    return lowestDiff;

}

Answer 2

  for (var i = 0; i < arr.length - 1; i++) {
      var j = i+1;//only check the diff with next neighbor
      diff[index] = Math.abs(arr[i] - arr[j]);
      console.log("index", i, j);
      index++;
  }

Answer 3

This is a nice opportunity to use the Array.map method because it allows us access to the currentValue being iterated, the index of the iteration, and the array we're currently reducing. Here's how the function would look:

function minimumAbsoluteDifference(array) {
  const sortedArray = [...array].sort((a, b) => a - b);
  let difference = sortedArray[sortedArray.length - 1];

  sortedArray.map((currentValue, index, array) => {
    const currentMinDifference = Math.abs(currentValue - array[index + 1]);

    if (currentMinDifference < difference) {
      difference = currentMinDifference;
    }
  });

  return difference;
}

First, we sort the array to make it easier to work with and then we initialize the difference to be the largest item in the array.

Then we call the map method on the sorted array with the provided callback taking the currentValue, index, and array as arguments.

Inside the map method is where we will calculate the absolute differences between the current number and the next. If the absolute difference for the current iteration is smaller than difference , then we've found a smaller absolute difference in the array.

This goes on till the end.