Find the value of K after replacing every index of the array by |ai – K|

Given an array, arr[] containing n integers, the task is to find an integer (say K) such that after replacing each and every index of the array by |a_i  – K| where ( i ∈ [1, n]), results in a sorted array. If no such integer exists that satisfies the above condition then return -1.

Examples:

Input: arr[ ] = [10, 5, 4, 3, 2, 1]
Output: 8
Explanation: Upon performing the operation |a_i-8|, we get [2, 3, 4, 5, 6, 7] which is sorted.

Input: arr[ ] = [1, 2, 3, 4, 5, 6] 
Output: 0
Explanation: Since the array is already sorted so the value of K would be 0 in this case.

Approach: The problem can be solved based on the following observation:

Observations:

For the array to be sorted each pair of adjacent elements should be sorted. That means few cases arise if we take care for particular a_i and a_i+1 and those are as follows:

• Let (a_i < a_i+1 ), so the following inequality arise: 
  • If (K ≤a_i) then upon  (a_i – K ≤ a_i+1 – K) the elements will be as it is (a_i < a_i+1).
  • If (K ≥ a_i) then upon  ( K – a_i ≤ K – a_i+1 ) the elements will be as it is (ai > a_i+1).
  • So, K should be midway between a_i and a_i+1 that is K should be K ≤ (a_i + a_i+1)/2 .
• Similarly for (a_i > a_i+1) the value of k would be K ≥ (a_i + a_i+1)/2 
• Finally we will take the minimum of all for which (K < a_i) and maximum of all for which (K > a_i).

Follow the steps mentioned below to implement the idea:

• Initialize two variables l and r for the two values of k explained above.
• Iterate over the array and check if (a_i < a_i+1) then store in r the minimum of r so far and the present value of K.
• Else if, (a_i > a_i+1) stores it in l the maximum of l so far and the present value of K.
• Finally if (l > r) return -1;
• Else, return l 

Below is the Implementation of the above approach: 

C++

// C++ code for the above approach:
#include <bits/stdc++.h>
using namespace std;

// Function to find K
void findk(int a[], int n)
{

    // Initializing the two variables
    int l = 0, r = 1e9;

    for (int i = 0; i < n - 1; i++) {

        // If (a[i] < a[i+1]) then take
        // minimum and store in variable

        if (a[i] < a[i + 1]) {
            r = min(r, (a[i] + a[i + 1]) / 2);
        }

        // If (a[i]>a[i+1]) then take
        // maximum and store in
        // seperate variable
        else if (a[i] > a[i + 1]) {
            l = max(l, (a[i] + a[i + 1] + 1) / 2);
        }
    }

    if (l > r) {
        cout << "-1";
    }

    else

        cout << l << endl;
}

// Driver function
int main()
{
    int arr[] = { 10, 5, 4, 3, 2, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);

    // Function Call
    findk(arr, n);
    return 0;
}

Java

// Java Implementation

import java.util.*;

class GFG {
    public static void main(String[] args)
    {
        int[] arr = { 10, 5, 4, 3, 2, 1 };
        int n = arr.length;
        find(arr, n);
    }

    public static void find(int[] arr, int n)
    {
        // Initializing the two variables
        int l = 0;
        int r = 1000000000;
        for (int i = 0; i < n - 1; i++) {

            // If (a[i]<a[i+1]) then take minimum and store in variable)

            if (arr[i] < arr[i + 1]) {
                r = Math.min(r, (arr[i] + arr[i + 1]) / 2);
            }

            // If (a[i]>a[i+1]) then take maximum and store in seperate variable)

            else if (arr[i] > arr[i + 1]) {
                l = Math.max(l,
                             (arr[i] + arr[i + 1] + 1) / 2);
            }
        }

        if (l > r) {
            System.out.println(-1);
        }
        else {
            System.out.println(l);
        }
    }
}

Python3

# Python code for the above approach

# Function to find K
def findk(a, n):

    # Initializing the two variables
    l = 0
    r = 10**9

    for i in range(n - 1):

        # If (a[i] < a[i+1]) then take
        # minimum and store in variable
        if (a[i] < a[i + 1]):
            r = min(r, (a[i] + a[i + 1]) // 2)

        # If (a[i]>a[i+1]) then take
        # maximum and store in
        # seperate variable
        elif (a[i] > a[i + 1]):
            l = max(l, (a[i] + a[i + 1] + 1) // 2)

    if (l > r):
        print("-1")

    else:
        print(l)

# Driver function
if __name__ == '__main__':
    arr = [10, 5, 4, 3, 2, 1]
    n = len(arr)

    # Function Call
    findk(arr, n)

C#

// C# code for the above approach:
using System;
public class GFG {

  static public void Main()
  {

    // Code
    int[] arr = { 10, 5, 4, 3, 2, 1 };
    int n = arr.Length;
    find(arr, n);
  }

  static void find(int[] arr, int n)
  {

    // Initializing the two variables
    int l = 0;
    int r = 1000000000;
    for (int i = 0; i < n - 1; i++)
    {

      // If (a[i]<a[i+1]) then take minimum and store
      // in variable)
      if (arr[i] < arr[i + 1]) {
        r = Math.Min(r, (arr[i] + arr[i + 1]) / 2);
      }

      // If (a[i]>a[i+1]) then take maximum and store
      // in seperate variable)
      else if (arr[i] > arr[i + 1]) {
        l = Math.Max(l,
                     (arr[i] + arr[i + 1] + 1) / 2);
      }
    }

    if (l > r) {
      Console.WriteLine(-1);
    }
    else {
      Console.WriteLine(l);
    }
  }
}

// This code is contributed by karthik

Javascript

// JavaScript code for the above approach:

// Function to find K
function findk(a, n) {

    // Initializing the two variables
    let l = 0, r = 1e9;

    for (let i = 0; i < n - 1; i++) {

        // If (a[i] < a[i+1]) then take
        // minimum and store in variable
        if (a[i] < a[i + 1]) {
            r = Math.min(r, Math.floor((a[i] + a[i + 1]) / 2));
        }

        // If (a[i]>a[i+1]) then take
        // maximum and store in
        // seperate variable
        else if (a[i] > a[i + 1]) {
            l = Math.max(l, Math.ceil((a[i] + a[i + 1]) / 2));
        }
    }

    if (l > r) {
        console.log("-1");
    }
    else {
        console.log(l);
    }
}

// Driver function
var arr = [10, 5, 4, 3, 2, 1];
var n = arr.length;

// Function Call
findk(arr, n);
// This code is contributed by prasad264

Output

8

Time Complexity: O(n), iterating the loop for once only.
Auxiliary Space: O(1), no extra space is used.