Find minimum difference with adjacent elements in Array
Given an array A[] of N integers, the task is to find min(A[0], A[1], …, A[i-1]) – min(A[i+1], A[i+2], …, A[n-1]) for each i (1 ≤ i ≤ N).
Note: If there are no elements at the left or right of i then consider the minimum element towards that part zero.
Examples:
Input: N = 4, A = {8, 4, 2, 6}
Output: -2 6 -2 2Input: N = 1, A = {55}
Output: 0
Approach 1: Bruteforce (Naive Approach)
The brute force approach calculates the difference between the left and right subarrays minimum of each element in the input array by iterating through the array arr[] and getting the minimum of the elements to the left and right of each element separately. This approach has a time complexity of O(N^2), where N is the size of the input array.
Below are the steps involved in the implementation of the code:
- Create an empty array res to store the absolute difference for each element of the input array.
- Iterate through the input array arr, and for each element arr[i], do the following:
- Create two variables leftMin and rightMin, both initialized to the maximum value of an integer. These variables will store the minimum of the elements to the left and to the right of the current element, respectively.
- Calculate the left Min by iterating from the first element of the array up to arr[i]-1 and comparing each element to leftMin. if leftMin is greater than the current element update leftMin.
- Calculate the right Min by iterating from arr[i]+1 up to the last element of the array and comparing each element to rightMin. if rightMin is greater than the current element update rightMin.
- If leftMin == INT_MAX (maximum value of integer) means there is no element on the left side so set leftMin=0
- If rightMin == INT_MAX (maximum value of integer) means there is no element on the right side so set rightMin=0
- Calculate the difference between leftMin and rightMin using (leftMin – rightMin).
- Add the difference to the result array res[].
- Return the result array.
Below is the implementation for the above approach:
C++
// C++ Implementation #include <bits/stdc++.h> using namespace std; // Function to find difference array vector< int > findDifferenceArray(vector< int >& arr) { int n = arr.size(); vector< int > res(n); // Iterate in array arr[] for ( int i = 0; i < n; i++) { int leftMin = INT_MAX, rightMin = INT_MAX; // calculate left minimum for ( int j = 0; j < i; j++) leftMin = min(leftMin, arr[j]); // calculate right minimum for ( int j = i + 1; j < n; j++) rightMin = min(rightMin, arr[j]); // means there is no element in left side if (leftMin == INT_MAX) leftMin = 0; // means there is no element in right side if (rightMin == INT_MAX) rightMin = 0; // add difference to result array res[i] = leftMin - rightMin; } return res; } // Driver code int main() { int N = 4; vector< int > arr = { 8, 4, 2, 6 }; // Function call vector< int > ans = findDifferenceArray(arr); for ( int i = 0; i < N; i++) cout << ans[i] << " " ; return 0; } |
Java
// Java Implementation import java.util.*; public class GFG { // Function to find difference array public static List<Integer> findDifferenceArray(List<Integer> arr) { int n = arr.size(); List<Integer> res = new ArrayList<Integer>(n); // Iterate in array arr[] for ( int i = 0 ; i < n; i++) { int leftMin = Integer.MAX_VALUE, rightMin = Integer.MAX_VALUE; // calculate left minimum for ( int j = 0 ; j < i; j++) leftMin = Math.min(leftMin, arr.get(j)); // calculate right minimum for ( int j = i + 1 ; j < n; j++) rightMin = Math.min(rightMin, arr.get(j)); // means there is no element in left side if (leftMin == Integer.MAX_VALUE) leftMin = 0 ; // means there is no element in right side if (rightMin == Integer.MAX_VALUE) rightMin = 0 ; // add difference to result array res.add(leftMin - rightMin); } return res; } // Driver code public static void main(String[] args) { int N = 4 ; List<Integer> arr = new ArrayList<Integer>( Arrays.asList( 8 , 4 , 2 , 6 )); // Function call List<Integer> ans = findDifferenceArray(arr); for ( int i = 0 ; i < N; i++) System.out.print(ans.get(i) + " " ); } } |
Python3
# Python Implementation # Function to find difference array def find_difference_array(arr): n = len (arr) res = [] # Iterate in array arr[] for i in range (n): left_min = float ( 'inf' ) right_min = float ( 'inf' ) # calculate left minimum for j in range (i): left_min = min (left_min, arr[j]) # calculate right minimum for j in range (i + 1 , n): right_min = min (right_min, arr[j]) # means there is no element in left side if left_min = = float ( 'inf' ): left_min = 0 # means there is no element in right side if right_min = = float ( 'inf' ): right_min = 0 # add difference to result array res.append(left_min - right_min) return res # Driver code N = 4 arr = [ 8 , 4 , 2 , 6 ] # Function call ans = find_difference_array(arr) for i in range (N): print (ans[i], end = " " ) # This code is contributed by Pushpesh Raj |
C#
using System; using System.Collections.Generic; class GFG { // Function to find difference array static List< int > FindDifferenceArray(List< int > arr) { int n = arr.Count; List< int > res = new List< int >(n); // Iterate in array arr[] for ( int i = 0; i < n; i++) { int leftMin = int .MaxValue, rightMin = int .MaxValue; // calculate left minimum for ( int j = 0; j < i; j++) leftMin = Math.Min(leftMin, arr[j]); // calculate right minimum for ( int j = i + 1; j < n; j++) rightMin = Math.Min(rightMin, arr[j]); // means there is no element on the left side if (leftMin == int .MaxValue) leftMin = 0; // means there is no element on the right side if (rightMin == int .MaxValue) rightMin = 0; // add the difference to the result array res.Add(leftMin - rightMin); } return res; } // Driver code static void Main() { List< int > arr = new List< int >{ 8, 4, 2, 6 }; // Function call List< int > ans = FindDifferenceArray(arr); foreach ( int diff in ans) Console.Write(diff + " " ); Console.WriteLine(); } } // This code is contributed by shivamgupta310570 |
Javascript
// 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 |
-2 6 -2 2
Time complexity: O(N^2)
Auxiliary Space: O(1)
Approach 2: This can be solved with the following idea:
Store all the elements in map and start iterating in array. Get the first element of map as smallest element from right subarray and maintain a minima for left subarray.
Below is the implementation of the above approach:
C++
// C++ Implementation #include <bits/stdc++.h> using namespace std; // Function to find difference array void findDifferenceArray( int N, vector< int >& A) { // Map Intialisation map< int , int > m; int i = 0; while (i < A.size()) { m[A[i]]++; i++; } int minn = INT_MAX; i = 0; vector< int > v; while (i < A.size()) { m[A[i]]--; if (m[A[i]] == 0) { m.erase(A[i]); } int up = 0; // Minimum element from // right subarray for ( auto a : m) { up = a.first; break ; } if (i == 0) { v.push_back(0 - up); } else { v.push_back(minn - up); } // Minimum from left subarray minn = min(minn, A[i]); i++; } for ( auto a : v) { cout << a << " " ; } } // Driver code int main() { int N = 4; vector< int > A = { 8, 4, 2, 6 }; // Function call findDifferenceArray(N, A); return 0; } |
Java
/*package whatever // do not write package name here */ import java.io.*; class GFG { public static int [] findDifferenceArray( int N, int A[]) { // store the result in res[] int res[] = new int [N]; // If there is only one element than return 0 if (N == 1 ) return res; int mini = Integer.MAX_VALUE; int mini1 = Integer.MAX_VALUE; int [] left = new int [N]; int [] right = new int [N]; // right vector store the suffix minimum value till // ith element for ( int i = N - 2 ; i >= 0 ; i--) { mini = Math.min(mini, A[i + 1 ]); right[i] = mini; } // left vector store the prefix minimum value till // ith element for ( int i = 1 ; i < N; i++) { mini1 = Math.min(mini1, A[i - 1 ]); left[i] = mini1; } // left_min[]-right_min[] for ( int i = 0 ; i < N; i++) { res[i] = left[i] - right[i]; } // return result in res array return res; } public static void main(String[] args) { int N = 4 ; int A[] = { 8 , 4 , 2 , 6 }; // result has min(0, ..i-1)-min(i+1, ..N-1) int [] result = findDifferenceArray(N, A); // print the result array value for ( int i = 0 ; i < N; i++) { System.out.print(result[i] + " " ); } } } |
Python3
class GFG: @staticmethod def findDifferenceArray(N, A): # store the result in res[] res = [ 0 ] * N # If there is only one element than return 0 if N = = 1 : return res mini = float ( 'inf' ) mini1 = float ( 'inf' ) left = [ 0 ] * N right = [ 0 ] * N # right vector store the suffix minimum value till # ith element for i in range (N - 2 , - 1 , - 1 ): mini = min (mini, A[i + 1 ]) right[i] = mini # left vector store the prefix minimum value till # ith element for i in range ( 1 , N): mini1 = min (mini1, A[i - 1 ]) left[i] = mini1 # left_min[]-right_min[] for i in range (N): res[i] = left[i] - right[i] # return result in res array return res @staticmethod def main(): N = 4 A = [ 8 , 4 , 2 , 6 ] # result has min(0, ..i-1)-min(i+1, ..N-1) result = GFG.findDifferenceArray(N, A) # print the result array value for i in range (N): print (result[i], end = " " ) GFG.main() |
C#
// C# code implementation: using System; public class GFG { static int [] findDifferenceArray( int N, int [] A) { // store the result in res[] int [] res = new int [N]; // If there is only one element than return 0 if (N == 1) { return res; } int mini = Int32.MaxValue; int mini1 = Int32.MaxValue; int [] left = new int [N]; int [] right = new int [N]; // right vector store the suffix minimum value till // ith element for ( int i = N - 2; i >= 0; i--) { mini = Math.Min(mini, A[i + 1]); right[i] = mini; } // left vector store the prefix minimum value till // ith element for ( int i = 1; i < N; i++) { mini1 = Math.Min(mini1, A[i - 1]); left[i] = mini1; } // left_min[]-right_min[] for ( int i = 0; i < N; i++) { res[i] = left[i] - right[i]; } // return result in res array return res; } static public void Main() { // Code int N = 4; int [] A = { 8, 4, 2, 6 }; // result has min(0, ..i-1)-min(i+1, ..N-1) int [] result = findDifferenceArray(N, A); // print the result array value for ( int i = 0; i < N; i++) { Console.Write(result[i] + " " ); } } } // This code is contributed by sankar. |
Javascript
// 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] + " " ); } } } |
-2 6 -2 2
Time Complexity: O(N)
Auxiliary Space: O(N)
Contact Us