Find minimum difference with adjacent elements in Array

// Function to find difference array
function findDifferenceArray(arr) {
    const n = arr.length;
    const res = new Array(n);

    // Iterate through array arr[]
    for (let i = 0; i < n; i++) {
        let leftMin = Infinity;
        let rightMin = Infinity;

        // Calculate left minimum
        for (let j = 0; j < i; j++)
            leftMin = Math.min(leftMin, arr[j]);

        // Calculate right minimum
        for (let j = i + 1; j < n; j++)
            rightMin = Math.min(rightMin, arr[j]);

        // Means there is no element on the left side
        if (leftMin === Infinity)
            leftMin = 0;

        // Means there is no element on the right side
        if (rightMin === Infinity)
            rightMin = 0;

        // Add difference to the result array
        res[i] = leftMin - rightMin;
    }

    return res;
}

// Driver code
const arr = [8, 4, 2, 6];

// Function call
const ans = findDifferenceArray(arr);

for (let i = 0; i < arr.length; i++)
    console.log(ans[i]);
// This code is contributed by Aditi Tyagi

// Define a class GFG
class GFG {
  // Define a static method called 
  // findDifferenceArray that takes 
  // an integer N and an integer array
  // A as input and returns an integer array
  static findDifferenceArray(N, A) {
    // Create an empty integer array called res with length N
    let res = new Array(N);

    // If the length of the array is 1, return an empty array res
    if (N === 1) {
      return res;
    }

    // Initialize mini and mini1 as the maximum integer value
    let mini = Number.MAX_SAFE_INTEGER;
    let mini1 = Number.MAX_SAFE_INTEGER;

    // Create two empty integer arrays 
    // called left and right with length N
    let left = new Array(N);
    let right = new Array(N);

    // right vector store the suffix minimum value till ith element
    for (let i = N - 2; i >= 0; i--) 
    {
    
      // Calculate the minimum value from 
      // the i+1th element to the end of the array A
      mini = Math.min(mini, A[i + 1]);
      
      // Store the minimum value in the right array at the ith index
      right[i] = mini;
    }

    // left vector store the prefix minimum value till ith element
    for (let i = 1; i < N; i++)
    {
    
      // Calculate the minimum value from 
      // the beginning of the array A to the ith element
      mini1 = Math.min(mini1, A[i - 1]);
      
      // Store the minimum value in the left array at the ith index
      left[i] = mini1;
    }

    // left_min[]-right_min[]
    for (let i = 0; i < N; i++)
    {
    
      // Calculate the difference between 
      // the ith index of the left array and 
      // the ith index of the right array and 
      // store it in the ith index of the res array
      res[i] = left[i] - right[i];
    }

    // Return the res array
    return res;
  }

  // Define a static method called main that 
  // does not return a value and takes no arguments
  static main() 
  {
  
    // Initialize N to 4 and A to 
    // an integer array containing 8, 4, 2, and 6
    let N = 4;
    let A = [8, 4, 2, 6];

    // Set the result equal to the result of 
    // calling findDifferenceArray with N and A as arguments
    let result = GFG.findDifferenceArray(N, A);

    // Print each element of the result array separated by a space
    for (let i = 0; i < N; i++) {
      console.log(result[i] + " ");
    }
  }
}