Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Replace elements with absolute difference of smallest element on left and largest element on right

  • Last Updated : 20 May, 2021

Given an array arr[] of N integers. The task is to replace all the elements of the array by the absolute difference of the smallest element on its left and the largest element on its right.
Examples: 
 

Input: arr[] = {1, 5, 2, 4, 3} 
Output: 5 3 3 2 1 
 

ElementSmallest on its leftLargest on its rightAbsolute difference
1NULL55
5143
2143
4132
31NULL1

Input: arr[] = {4, 3, 6, 2, 1, 20, 9, 10, 15, 6} 
Output: 20 16 17 17 18 14 14 14 5 1 
 

 

Naive approach: For every element arr[i] of the array, find the minimum element in the subarray arr[0…i-1] then the maximum element in the subarray arr[i+1…n-1] and print the absolute difference between the two. The time complexity of this approach will be O(N2).
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Utility function to print the
// elements of an array
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
}
 
// Function to return the minimum element
// in the subarray arr[i...j]
int getMin(int arr[], int i, int j)
{
 
    // To store the minimum element
    int minVal = arr[i++];
    while (i <= j) {
 
        // Update the minimum element so far
        minVal = min(minVal, arr[i]);
        i++;
    }
 
    // Return the minimum element found
    return minVal;
}
 
// Function to return the maximum element
// in the subarray arr[i...j]
int getMax(int arr[], int i, int j)
{
 
    // To store the maximum element
    int maxVal = arr[i++];
    while (i <= j) {
 
        // Update the maximum element so far
        maxVal = max(maxVal, arr[i]);
        i++;
    }
 
    // Return the maximum element found
    return maxVal;
}
 
// Function to generate the array
// with the given operations
void generateArr(int arr[], int n)
{
 
    // Base cases
    if (n == 0)
        return;
    if (n == 1) {
        cout << arr[0];
        return;
    }
 
    // To store the new array elements
    int tmpArr[n];
 
    // The first element has no
    // element on its left
    tmpArr[0] = getMax(arr, 1, n - 1);
 
    // From the second element to the
    // second last element
    for (int i = 1; i < n - 1; i++) {
 
        // Absolute difference of the maximum
        // element to the right and the
        // minimum element to the left
        tmpArr[i] = abs(getMax(arr, i + 1, n - 1)
                        - getMin(arr, 0, i - 1));
    }
 
    // The last element has no
    // element on its right
    tmpArr[n - 1] = getMin(arr, 0, n - 2);
 
    // Print the generated array
    printArray(tmpArr, n);
}
 
// Driver code
int main()
{
    int arr[] = { 1, 5, 2, 4, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    generateArr(arr, n);
 
    return 0;
}

Java




// Java implementation of the approach
class GFG
{
     
// Utility function to print the
// elements of an array
static void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
    {
        System.out.print(arr[i] + " ");
    }
}
 
// Function to return the minimum element
// in the subarray arr[i...j]
static int getMin(int arr[], int i, int j)
{
 
    // To store the minimum element
    int minVal = arr[i++];
    while (i <= j)
    {
 
        // Update the minimum element so far
        minVal = Math.min(minVal, arr[i]);
        i++;
    }
 
    // Return the minimum element found
    return minVal;
}
 
// Function to return the maximum element
// in the subarray arr[i...j]
static int getMax(int arr[], int i, int j)
{
 
    // To store the maximum element
    int maxVal = arr[i++];
    while (i <= j)
    {
 
        // Update the maximum element so far
        maxVal = Math.max(maxVal, arr[i]);
        i++;
    }
 
    // Return the maximum element found
    return maxVal;
}
 
// Function to generate the array
// with the given operations
static void generateArr(int arr[], int n)
{
 
    // Base cases
    if (n == 0)
        return;
    if (n == 1)
    {
        System.out.println(arr[0]);
        return;
    }
 
    // To store the new array elements
    int tmpArr[] = new int[n];
 
    // The first element has no
    // element on its left
    tmpArr[0] = getMax(arr, 1, n - 1);
 
    // From the second element to the
    // second last element
    for (int i = 1; i < n - 1; i++)
    {
 
        // Absolute difference of the maximum
        // element to the right and the
        // minimum element to the left
        tmpArr[i] = Math.abs(getMax(arr, i + 1, n - 1) -
                             getMin(arr, 0, i - 1));
    }
 
    // The last element has no
    // element on its right
    tmpArr[n - 1] = getMin(arr, 0, n - 2);
 
    // Print the generated array
    printArray(tmpArr, n);
}
 
// Driver code
public static void main (String[] args)
{
    int arr[] = { 1, 5, 2, 4, 3 };
    int n = arr.length;
 
    generateArr(arr, n);
}
}
 
// This code is contributed by AnkitRai01

Python3




# Python3 implementation of the approach
 
# Utility function to print the
# elements of an array
def printArray(arr, n):
    for i in range(n):
        print(arr[i], end = " ")
 
# Function to return the minimum element
# in the subarray arr[i...j]
def getMin(arr, i, j):
 
    # To store the minimum element
    minVal = arr[i]
    i += 1
    while (i <= j):
 
        # Update the minimum element so far
        minVal = min(minVal, arr[i])
        i += 1
 
    # Return the minimum element found
    return minVal
 
# Function to return the maximum element
# in the subarray arr[i...j]
def getMax(arr, i, j):
 
    # To store the maximum element
    maxVal = arr[i]
    i += 1
    while (i <= j):
 
        # Update the maximum element so far
        maxVal = max(maxVal, arr[i])
        i += 1
 
    # Return the maximum element found
    return maxVal
 
# Function to generate the array
# With the given operations
def generateArr(arr, n):
 
    # Base cases
    if (n == 0):
        return
    if (n == 1):
        print(arr[0], end = "")
        return
 
    # To store the new array elements
    tmpArr = [0 for i in range(n)]
 
    # The first element has no
    # element on its left
    tmpArr[0] = getMax(arr, 1, n - 1)
 
    # From the second element to the
    # second last element
    for i in range(1, n - 1):
 
        # Absolute difference of the maximum
        # element to the right and the
        # minimum element to the left
        tmpArr[i] = abs(getMax(arr, i + 1, n - 1) -
                        getMin(arr, 0, i - 1))
 
    # The last element has no
    # element on its right
    tmpArr[n - 1] = getMin(arr, 0, n - 2)
 
    # Print the generated array
    printArray(tmpArr, n)
 
# Driver code
arr = [1, 5, 2, 4, 3]
n = len(arr)
 
generateArr(arr, n)
 
# This code is contributed by Mohit Kumar

C#




// C# implementation of the approach
using System;
 
class GFG
{
         
// Utility function to print the
// elements of an array
static void printArray(int []arr, int n)
{
    for (int i = 0; i < n; i++)
    {
        Console.Write(arr[i] + " ");
    }
}
 
// Function to return the minimum element
// in the subarray arr[i...j]
static int getMin(int []arr, int i, int j)
{
 
    // To store the minimum element
    int minVal = arr[i++];
    while (i <= j)
    {
 
        // Update the minimum element so far
        minVal = Math.Min(minVal, arr[i]);
        i++;
    }
 
    // Return the minimum element found
    return minVal;
}
 
// Function to return the maximum element
// in the subarray arr[i...j]
static int getMax(int []arr, int i, int j)
{
 
    // To store the maximum element
    int maxVal = arr[i++];
    while (i <= j)
    {
 
        // Update the maximum element so far
        maxVal = Math.Max(maxVal, arr[i]);
        i++;
    }
 
    // Return the maximum element found
    return maxVal;
}
 
// Function to generate the array
// with the given operations
static void generateArr(int []arr, int n)
{
 
    // Base cases
    if (n == 0)
        return;
    if (n == 1)
    {
        Console.WriteLine(arr[0]);
        return;
    }
 
    // To store the new array elements
    int []tmpArr = new int[n];
 
    // The first element has no
    // element on its left
    tmpArr[0] = getMax(arr, 1, n - 1);
 
    // From the second element to the
    // second last element
    for (int i = 1; i < n - 1; i++)
    {
 
        // Absolute difference of the maximum
        // element to the right and the
        // minimum element to the left
        tmpArr[i] = Math.Abs(getMax(arr, i + 1, n - 1) -
                             getMin(arr, 0, i - 1));
    }
 
    // The last element has no
    // element on its right
    tmpArr[n - 1] = getMin(arr, 0, n - 2);
 
    // Print the generated array
    printArray(tmpArr, n);
}
 
// Driver code
static public void Main ()
{
    int []arr = { 1, 5, 2, 4, 3 };
    int n = arr.Length;
 
    generateArr(arr, n);
}
}
 
// This code is contributed by ajit.

Javascript




<script>
 
    // JavaScript implementation of the approach
     
    // Utility function to print the
    // elements of an array
    function printArray(arr, n)
    {
        for (let i = 0; i < n; i++)
        {
            document.write(arr[i] + " ");
        }
    }
 
    // Function to return the minimum element
    // in the subarray arr[i...j]
    function getMin(arr, i, j)
    {
 
        // To store the minimum element
        let minVal = arr[i++];
        while (i <= j)
        {
 
            // Update the minimum element so far
            minVal = Math.min(minVal, arr[i]);
            i++;
        }
 
        // Return the minimum element found
        return minVal;
    }
 
    // Function to return the maximum element
    // in the subarray arr[i...j]
    function getMax(arr, i, j)
    {
 
        // To store the maximum element
        let maxVal = arr[i++];
        while (i <= j)
        {
 
            // Update the maximum element so far
            maxVal = Math.max(maxVal, arr[i]);
            i++;
        }
 
        // Return the maximum element found
        return maxVal;
    }
 
    // Function to generate the array
    // with the given operations
    function generateArr(arr, n)
    {
 
        // Base cases
        if (n == 0)
            return;
        if (n == 1)
        {
            document.write(arr[0] + "</br>");
            return;
        }
 
        // To store the new array elements
        let tmpArr = new Array(n);
        tmpArr.fill(0);
 
        // The first element has no
        // element on its left
        tmpArr[0] = getMax(arr, 1, n - 1);
 
        // From the second element to the
        // second last element
        for (let i = 1; i < n - 1; i++)
        {
 
          // Absolute difference of the maximum
         // element to the right and the
        // minimum element to the left
           tmpArr[i] = Math.abs(getMax(arr, i + 1, n - 1) -
                                 getMin(arr, 0, i - 1));
        }
 
        // The last element has no
        // element on its right
        tmpArr[n - 1] = getMin(arr, 0, n - 2);
 
        // Print the generated array
        printArray(tmpArr, n);
    }
     
    let arr = [ 1, 5, 2, 4, 3 ];
    let n = arr.length;
   
    generateArr(arr, n);
 
// This code is contributed by suresh07.
 
</script>
Output: 
5 3 3 2 1

 

Efficient approach: Create an array suffixMax[] where suffixMax[i] will store the maximum element in the subarray arr[i…N-1]. Also take a variable minSoFar which will store the minimum element so far on traversing the array from left to right. Now, for every element arr[i] the updated value will be abs(suffixMax[i + 1] – minSoFar).
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Utility function to print the
// elements of an array
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
}
 
// Function to generate the array
// with the given operations
void generateArr(int arr[], int n)
{
 
    // Base cases
    if (n == 0)
        return;
    if (n == 1) {
        cout << arr[0];
        return;
    }
 
    // To suffixMax[i] will store the maximum
    // element in the subarray arr[i...n-1]
    int suffixMax[n];
    suffixMax[n - 1] = arr[n - 1];
    for (int i = n - 2; i >= 0; i--)
        suffixMax[i] = max(arr[i], suffixMax[i + 1]);
 
    // To store the minimum element on the left
    int minSoFar = arr[0];
 
    // The first element has no
    // element on its left
    arr[0] = suffixMax[1];
 
    // From the second element to the
    // second last element
    for (int i = 1; i < n - 1; i++) {
 
        // Store a copy of the currene element
        int temp = arr[i];
 
        // Absolute difference of the maximum
        // element to the right and the
        // minimum element to the left
        arr[i] = abs(suffixMax[i + 1] - minSoFar);
 
        // Update the minimum element so far
        minSoFar = min(minSoFar, temp);
    }
 
    // The last element has no
    // element on its right
    arr[n - 1] = minSoFar;
 
    // Print the updated array
    printArray(arr, n);
}
 
// Driver code
int main()
{
    int arr[] = { 1, 5, 2, 4, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    generateArr(arr, n);
 
    return 0;
}

Java




// Java implementation of the approach
class GFG
{
 
// Utility function to print the
// elements of an array
static void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
    {
        System.out.print(arr[i] + " ");
    }
}
 
 
 
 
// Function to generate the array
// with the given operations
static void generateArr(int arr[], int n)
{
 
    // Base cases
    if (n == 0)
        return;
    if (n == 1)
    {
        System.out.print(arr[0]);
        return;
    }
 
    // To suffixMax[i] will store the maximum
    // element in the subarray arr[i...n-1]
    int []suffixMax = new int[n];
    suffixMax[n - 1] = arr[n - 1];
    for (int i = n - 2; i >= 0; i--)
        suffixMax[i] = Math.max(arr[i],
                                suffixMax[i + 1]);
 
    // To store the minimum element on the left
    int minSoFar = arr[0];
 
    // The first element has no
    // element on its left
    arr[0] = suffixMax[1];
 
    // From the second element to the
    // second last element
    for (int i = 1; i < n - 1; i++)
    {
 
        // Store a copy of the currene element
        int temp = arr[i];
 
        // Absolute difference of the maximum
        // element to the right and the
        // minimum element to the left
        arr[i] = Math.abs(suffixMax[i + 1] -
                                 minSoFar);
 
        // Update the minimum element so far
        minSoFar = Math.min(minSoFar, temp);
    }
 
    // The last element has no
    // element on its right
    arr[n - 1] = minSoFar;
 
    // Print the updated array
    printArray(arr, n);
}
 
// Driver code
public static void main (String[] args)
{
    int arr[] = { 1, 5, 2, 4, 3 };
    int n = arr.length;
 
    generateArr(arr, n);
}
}
 
// This code is contributed by PrinciRaj1992

Python3




# Python 3 implementation of the approach
  
# Utility function to print the
# elements of an array
def printArray(arr, n):
 
    for i in range( n):
        print(arr[i],end= " ")
    
# Function to generate the array
# with the given operations
def generateArr(arr, n):
  
    # Base cases
    if (n == 0):
        return
    if (n == 1):
        print( arr[0])
        return
     
  
    # To suffixMax[i] will store the maximum
    # element in the subarray arr[i...n-1]
    suffixMax=[0]*n
    suffixMax[n - 1] = arr[n - 1]
    for i in range(n - 2, -1 ,-1):
        suffixMax[i] = max(arr[i], suffixMax[i + 1])
  
    # To store the minimum element on the left
    minSoFar = arr[0]
  
    # The first element has no
    # element on its left
    arr[0] = suffixMax[1]
  
    # From the second element to the
    # second last element
    for i in range( 1,n - 1):
  
        # Store a copy of the currene element
        temp = arr[i]
  
        # Absolute difference of the maximum
        # element to the right and the
        # minimum element to the left
        arr[i] = abs(suffixMax[i + 1] - minSoFar)
  
        # Update the minimum element so far
        minSoFar = min(minSoFar, temp)
    
  
    # The last element has no
    # element on its right
    arr[n - 1] = minSoFar
  
    # Print the updated array
    printArray(arr, n)
 
 
# Driver code
if __name__ == "__main__":
    arr = [ 1, 5, 2, 4, 3 ]
    n = len(arr)
    generateArr(arr, n)
 
# This code is contributed by chitranayal

C#




// C# implementation for above approach
using System;
 
class GFG
{
 
// Utility function to print the
// elements of an array
static void printArray(int []arr, int n)
{
    for (int i = 0; i < n; i++)
    {
        Console.Write(arr[i] + " ");
    }
}
 
 
 
// Function to generate the array
// with the given operations
static void generateArr(int []arr, int n)
{
 
    // Base cases
    if (n == 0)
        return;
    if (n == 1)
    {
        Console.Write(arr[0]);
        return;
    }
 
    // To suffixMax[i] will store the maximum
    // element in the subarray arr[i...n-1]
    int []suffixMax = new int[n];
    suffixMax[n - 1] = arr[n - 1];
    for (int i = n - 2; i >= 0; i--)
        suffixMax[i] = Math.Max(arr[i],
                                suffixMax[i + 1]);
 
    // To store the minimum element on the left
    int minSoFar = arr[0];
 
    // The first element has no
    // element on its left
    arr[0] = suffixMax[1];
 
    // From the second element to the
    // second last element
    for (int i = 1; i < n - 1; i++)
    {
 
        // Store a copy of the currene element
        int temp = arr[i];
 
        // Absolute difference of the maximum
        // element to the right and the
        // minimum element to the left
        arr[i] = Math.Abs(suffixMax[i + 1] -
                                 minSoFar);
 
        // Update the minimum element so far
        minSoFar = Math.Min(minSoFar, temp);
    }
 
    // The last element has no
    // element on its right
    arr[n - 1] = minSoFar;
 
    // Print the updated array
    printArray(arr, n);
}
 
// Driver code
public static void Main (String[] args)
{
    int []arr = { 1, 5, 2, 4, 3 };
    int n = arr.Length;
 
    generateArr(arr, n);
}
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
    // JavaScript implementation for above approach
     
    // Utility function to print the
    // elements of an array
    function printArray(arr, n)
    {
        for (let i = 0; i < n; i++)
        {
            document.write(arr[i] + " ");
        }
    }
 
 
 
    // Function to generate the array
    // with the given operations
    function generateArr(arr, n)
    {
 
        // Base cases
        if (n == 0)
            return;
        if (n == 1)
        {
            document.write(arr[0]);
            return;
        }
 
        // To suffixMax[i] will store the maximum
        // element in the subarray arr[i...n-1]
        let suffixMax = new Array(n);
        suffixMax.fill(0);
        suffixMax[n - 1] = arr[n - 1];
        for (let i = n - 2; i >= 0; i--)
            suffixMax[i] = Math.max(arr[i], suffixMax[i + 1]);
 
        // To store the minimum element on the left
        let minSoFar = arr[0];
 
        // The first element has no
        // element on its left
        arr[0] = suffixMax[1];
 
        // From the second element to the
        // second last element
        for (let i = 1; i < n - 1; i++)
        {
 
            // Store a copy of the currene element
            let temp = arr[i];
 
            // Absolute difference of the maximum
            // element to the right and the
            // minimum element to the left
            arr[i] = Math.abs(suffixMax[i + 1] -
                                     minSoFar);
 
            // Update the minimum element so far
            minSoFar = Math.min(minSoFar, temp);
        }
 
        // The last element has no
        // element on its right
        arr[n - 1] = minSoFar;
 
        // Print the updated array
        printArray(arr, n);
    }
     
    let arr = [ 1, 5, 2, 4, 3 ];
    let n = arr.length;
  
    generateArr(arr, n);
     
</script>
Output: 
5 3 3 2 1

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!