Maximum value of |arr[i] - arr[j]| + |i - j|

Last Updated : 25 Jun, 2026

Given an array arr[] of positive integers. Find maximum value of |arr[i] – arr[j]| + |i – j|, (0 <= i, j <= n – 1)

Examples: 

Input : arr[] = [1, 2, 3, 1] 
Output : 4
Explanation: Choose i = 0 and j = 2. This will result in |1-3|+|0-2| = 4 which is the maximum possible value.

Input : arr[] = [1, 1, 1 ]
Output : 2

Try It Yourself
redirect icon

Table of Content

[Naive Approach] Brute Force with Nested Loops - O(n²) Time and O(1) Space

Calculate the value |arr[i] - arr[j]| + |i - j| for every pair of indices (i, j) and track the maximum among all pairs.

C++ 
#include <bits/stdc++.h>
using namespace std;
#define MAX 10

// Return maximum value of |arr[i] - arr[j]| + |i - j|
int maxValue(vector<int>& arr)
{
    int n = arr.size();
    int ans = 0;

    // Iterating two for loop, one for 
    // i and another for j.
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)

            // Evaluating |arr[i] - arr[j]| + |i - j|
            // and compare with previous maximum.
            ans = max(ans,
                      abs(arr[i] - arr[j]) + abs(i - j));

    return ans;
}

// Driven Program
int main()
{
    vector<int> arr = { 1, 2, 3, 1 };
    
    cout << maxValue(arr) << endl;

    return 0;
}
Java 
// Java program to find maximum value of |arr[i] - arr[j]| + |i - j|
import java.util.*;

class GfG {
    
    // Return maximum value of |arr[i] - arr[j]| + |i - j|
    static int maxValue(int[] arr) {
        int n = arr.length;
        int ans = 0;
        
        // Iterating two for loop, one for i and another for j.
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                // Evaluating |arr[i] - arr[j]| + |i - j|
                // and compare with previous maximum.
                ans = Math.max(ans, Math.abs(arr[i] - arr[j]) + Math.abs(i - j));
            }
        }
        
        return ans;
    }
    
    // Driven Program
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 1};
        System.out.println(maxValue(arr));
    }
}
Python 
# Python program to find maximum value of |arr[i] - arr[j]| + |i - j|

# Return maximum value of |arr[i] - arr[j]| + |i - j|
def maxValue(arr):
    n = len(arr)
    ans = 0
    
    # Iterating two for loop, one for i and another for j.
    for i in range(n):
        for j in range(n):
            # Evaluating |arr[i] - arr[j]| + |i - j|
            # and compare with previous maximum.
            ans = max(ans, abs(arr[i] - arr[j]) + abs(i - j))
    
    return ans

# Driven Program
if __name__ == "__main__":
    arr = [1, 2, 3, 1]
    print(maxValue(arr))
C# 
// C# program to find maximum value of |arr[i] - arr[j]| + |i - j|
using System;

class GfG {
    
    // Return maximum value of |arr[i] - arr[j]| + |i - j|
    static int maxValue(int[] arr) {
        int n = arr.Length;
        int ans = 0;
        
        // Iterating two for loop, one for i and another for j.
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                // Evaluating |arr[i] - arr[j]| + |i - j|
                // and compare with previous maximum.
                ans = Math.Max(ans, Math.Abs(arr[i] - arr[j]) + Math.Abs(i - j));
            }
        }
        
        return ans;
    }
    
    // Driven Program
    static void Main(string[] args) {
        int[] arr = {1, 2, 3, 1};
        Console.WriteLine(maxValue(arr));
    }
}
JavaScript 
// JavaScript program to find maximum value of |arr[i] - arr[j]| + |i - j|

// Return maximum value of |arr[i] - arr[j]| + |i - j|
function maxValue(arr) {
    const n = arr.length;
    let ans = 0;
    
    // Iterating two for loop, one for i and another for j.
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            // Evaluating |arr[i] - arr[j]| + |i - j|
            // and compare with previous maximum.
            ans = Math.max(ans, Math.abs(arr[i] - arr[j]) + Math.abs(i - j));
        }
    }
    
    return ans;
}

// Driven Program
const arr = [1, 2, 3, 1];
console.log(maxValue(arr));

Output
4

[Expected Approach] Mathematical Transformation - O(n) Time and O(1) Space

The expression |arr[i] - arr[j]| + |i - j| can be rewritten as max of (arr[i] + i) - (arr[j] + j) and (arr[i] - i) - (arr[j] - j). So answer is max( max(arr[i]+i) - min(arr[i]+i), max(arr[i]-i) - min(arr[i]-i) ).

  • Initialize mx1 = -∞, mn1 = ∞, mx2 = -∞, mn2 = ∞.
  • Traverse array once.
  • Update mx1 = max(mx1, A[i] + i) and mn1 = min(mn1, A[i] + i).
  • Update mx2 = max(mx2, A[i] - i) and mn2 = min(mn2, A[i] - i).
  • Return max(mx1 - mn1, mx2 - mn2).
C++ 
#include <bits/stdc++.h>
using namespace std;

int maxValue(vector<int>& A) {
    int n = A.size();
    int mx1 = INT_MIN, mn1 = INT_MAX;
    int mx2 = INT_MIN, mn2 = INT_MAX;
    
    // Track max/min of (value + index) and (value - index)
    for(int i = 0; i < n; i++) {
        mx1 = max(mx1, A[i] + i);
        mn1 = min(mn1, A[i] + i);
        
        mx2 = max(mx2, A[i] - i);
        mn2 = min(mn2, A[i] - i);
    }
    
    // Answer is the larger difference between the two
    return max(mx1 - mn1, mx2 - mn2);
}

int main() {    
    vector<int> arr = {1, 2, 3, 1};
    cout << maxValue(arr) << endl;
    return 0;
}
Java 
// Efficient Java program to find maximum value of |arr[i] - arr[j]| + |i - j|
import java.util.*;

class GfG {
    
    static int maxValue(int[] A) {
        int n = A.length;
        int mx1 = Integer.MIN_VALUE, mn1 = Integer.MAX_VALUE;
        int mx2 = Integer.MIN_VALUE, mn2 = Integer.MAX_VALUE;
        
        // Track max/min of (value + index) and (value - index)
        for (int i = 0; i < n; i++) {
            mx1 = Math.max(mx1, A[i] + i);
            mn1 = Math.min(mn1, A[i] + i);
            
            mx2 = Math.max(mx2, A[i] - i);
            mn2 = Math.min(mn2, A[i] - i);
        }
        
        // Answer is the larger difference between the two
        return Math.max(mx1 - mn1, mx2 - mn2);
    }
    
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 1};
        System.out.println(maxValue(arr));
    }
}
Python 
# Efficient Python program to find maximum value of |arr[i] - arr[j]| + |i - j|

def maxValue(A):
    n = len(A)
    mx1 = -10**9
    mn1 = 10**9
    mx2 = -10**9
    mn2 = 10**9
    
    # Track max/min of (value + index) and (value - index)
    for i in range(n):
        mx1 = max(mx1, A[i] + i)
        mn1 = min(mn1, A[i] + i)
        
        mx2 = max(mx2, A[i] - i)
        mn2 = min(mn2, A[i] - i)
    
    # Answer is the larger difference between the two
    return max(mx1 - mn1, mx2 - mn2)

# Driver code
if __name__ == "__main__":
    arr = [1, 2, 3, 1]
    print(maxValue(arr))
C# 
// Efficient C# program to find maximum value of |arr[i] - arr[j]| + |i - j|
using System;

class GfG {
    
    static int maxValue(int[] A) {
        int n = A.Length;
        int mx1 = int.MinValue, mn1 = int.MaxValue;
        int mx2 = int.MinValue, mn2 = int.MaxValue;
        
        // Track max/min of (value + index) and (value - index)
        for (int i = 0; i < n; i++) {
            mx1 = Math.Max(mx1, A[i] + i);
            mn1 = Math.Min(mn1, A[i] + i);
            
            mx2 = Math.Max(mx2, A[i] - i);
            mn2 = Math.Min(mn2, A[i] - i);
        }
        
        // Answer is the larger difference between the two
        return Math.Max(mx1 - mn1, mx2 - mn2);
    }
    
    static void Main(string[] args) {
        int[] arr = {1, 2, 3, 1};
        Console.WriteLine(maxValue(arr));
    }
}
JavaScript 
// Efficient JavaScript program to find maximum value of |arr[i] - arr[j]| + |i - j|

function maxValue(A) {
    const n = A.length;
    let mx1 = -Infinity, mn1 = Infinity;
    let mx2 = -Infinity, mn2 = Infinity;
    
    // Track max/min of (value + index) and (value - index)
    for (let i = 0; i < n; i++) {
        mx1 = Math.max(mx1, A[i] + i);
        mn1 = Math.min(mn1, A[i] + i);
        
        mx2 = Math.max(mx2, A[i] - i);
        mn2 = Math.min(mn2, A[i] - i);
    }
    
    // Answer is the larger difference between the two
    return Math.max(mx1 - mn1, mx2 - mn2);
}

// Driver code
const arr = [1, 2, 3, 1];
console.log(maxValue(arr));

Output
4
Comment

Explore