 Open in App
Not now

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

• Difficulty Level : Medium
• Last Updated : 09 Mar, 2023

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 |ai  – 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 |ai-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 ai and ai+1 and those are as follows:

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

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 (ai < ai+1) then store in r the minimum of r so far and the present value of K.
• Else if, (ai > ai+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 ` `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);`   `    ``// 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 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 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.

My Personal Notes arrow_drop_up
Related Articles