Open In App

Missing occurrences of a number in an array such that maximum absolute difference of adjacent elements is minimum

Last Updated : 19 May, 2021
Improve
Improve
Like Article
Like
Save
Share
Report

Given an array arr[] of some positive integers and missing occurrence of a specific integer represented by -1, the task is to find that missing number such that maximum absolute difference between adjacent elements is minimum.
Examples: 
 

Input: arr[] = {-1, 10, -1, 12, -1} 
Output: 11 
Explanation: 
Differences of Adjacent elements – 
=> a[0] – a[1] = 11 – 10 = 1 
=> a[2] – a[1] = 11 – 10 = 1 
=> a[3] – a[2] = 12 – 11 = 1 
=> a[3] – a[4] = 12 – 11 = 1 
Maximum absolute difference of adjacent elements – 2 
Input: arr[] = {1,-1, 7, 5, 2, -1, 5} 
Output:
Explanation: 
Differences of Adjacent elements – 
=> a[1] – a[0] = 4 – 1 = 3 
=> a[2] – a[1] = 7 – 4 = 3 
=> a[2] – a[3] = 7 – 5 = 2 
=> a[3] – a[4] = 5 – 2 = 3 
=> a[5] – a[4] = 4 – 2 = 2 
=> a[6] – a[5] = 5 – 4 = 1 
Maximum absolute difference of adjacent elements – 3

Approach: The idea is to find the maximum and minimum adjacent element to the missing number and the missing number can be the average of these two values such that maximum absolute difference is minimum.
 

=> max = Maximum adjacent element
=> min = Minimum adjacent element

Missing number = (max + min)
                -------------
                      2

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the missing
// number such that maximum absolute
// difference between adjacent element
// is minimum
 
#include <bits/stdc++.h>
 
using namespace std;
 
// Function to find the missing
// number such that maximum
// absolute difference is minimum
int missingnumber(int n, int arr[])
{
    int mn = INT_MAX, mx = INT_MIN;
    // Loop to find the maximum and
    // minimum adjacent element to
    // missing number
    for (int i = 0; i < n; i++) {
 
        if (i > 0 && arr[i] == -1 &&
                 arr[i - 1] != -1) {
            mn = min(mn, arr[i - 1]);
            mx = max(mx, arr[i - 1]);
        }
 
        if (i < (n - 1) && arr[i] == -1 &&
                       arr[i + 1] != -1) {
            mn = min(mn, arr[i + 1]);
            mx = max(mx, arr[i + 1]);
        }
    }
     
    long long int res = (mx + mn) / 2;
    return res;
}
 
// Driver Code
int main()
{
    int n = 5;
    int arr[5] = { -1, 10, -1,
                       12, -1 };
    int ans = 0;
     
    // Function Call
    int res = missingnumber(n, arr);
    cout << res;
 
    return 0;
}


Java




// Java implementation of the missing
// number such that maximum absolute
// difference between adjacent element
// is minimum
import java.util.*;
class GFG{
 
// Function to find the missing
// number such that maximum
// absolute difference is minimum
static int missingnumber(int n, int arr[])
{
    int mn = Integer.MAX_VALUE,
        mx = Integer.MIN_VALUE;
     
    // Loop to find the maximum and
    // minimum adjacent element to
    // missing number
    for (int i = 0; i < n; i++)
    {
        if (i > 0 && arr[i] == -1 &&
                     arr[i - 1] != -1)
        {
            mn = Math.min(mn, arr[i - 1]);
            mx = Math.max(mx, arr[i - 1]);
        }
 
        if (i < (n - 1) && arr[i] == -1 &&
                           arr[i + 1] != -1)
        {
            mn = Math.min(mn, arr[i + 1]);
            mx = Math.max(mx, arr[i + 1]);
        }
    }
     
    int res = (mx + mn) / 2;
    return res;
}
 
// Driver Code
public static void main(String[] args)
{
    int n = 5;
    int arr[] = { -1, 10, -1,
                    12, -1 };
 
    // Function Call
    int res = missingnumber(n, arr);
    System.out.print(res);
}
}
 
// This code is contributed by 29AjayKumar


Python3




# Python3 implementation of the missing
# number such that maximum absolute
# difference between adjacent element
# is minimum
import sys
 
# Function to find the missing
# number such that maximum
# absolute difference is minimum
def missingnumber(n, arr) -> int:
     
    mn = sys.maxsize;
    mx = -sys.maxsize - 1;
 
    # Loop to find the maximum and
    # minimum adjacent element to
    # missing number
    for i in range(n):
        if (i > 0 and arr[i] == -1 and
                      arr[i - 1] != -1):
            mn = min(mn, arr[i - 1]);
            mx = max(mx, arr[i - 1]);
 
        if (i < (n - 1) and arr[i] == -1 and
                            arr[i + 1] != -1):
            mn = min(mn, arr[i + 1]);
            mx = max(mx, arr[i + 1]);
 
    res = (mx + mn) / 2;
     
    return res;
 
# Driver Code
if __name__ == '__main__':
     
    n = 5;
    arr = [ -1, 10, -1, 12, -1 ];
 
    # Function call
    res = missingnumber(n, arr);
    print(res);
 
# This code is contributed by amal kumar choubey


C#




// C# implementation of the missing
// number such that maximum absolute
// difference between adjacent element
// is minimum
using System;
class GFG{
 
// Function to find the missing
// number such that maximum
// absolute difference is minimum
static int missingnumber(int n, int []arr)
{
    int mn = Int32.MaxValue,
        mx = Int32.MinValue;
     
    // Loop to find the maximum and
    // minimum adjacent element to
    // missing number
    for (int i = 0; i < n; i++)
    {
        if (i > 0 && arr[i] == -1 &&
                     arr[i - 1] != -1)
        {
            mn = Math.Min(mn, arr[i - 1]);
            mx = Math.Max(mx, arr[i - 1]);
        }
 
        if (i < (n - 1) && arr[i] == -1 &&
                           arr[i + 1] != -1)
        {
            mn = Math.Min(mn, arr[i + 1]);
            mx = Math.Max(mx, arr[i + 1]);
        }
    }
     
    int res = (mx + mn) / 2;
    return res;
}
 
// Driver Code
public static void Main()
{
    int n = 5;
    int []arr = new int[]{ -1, 10, -1, 12, -1 };
 
    // Function Call
    int res = missingnumber(n, arr);
    Console.WriteLine(res);
}
}
 
// This code is contributed by Nidhi_biet


Javascript




<script>
 
// JavaScript implementation of the missing
// number such that maximum absolute
// difference between adjacent element
// is minimum
 
// Function to find the missing
// number such that maximum
// absolute difference is minimum
function missingnumber(n, arr)
{
    let mn = 10000;
    let mx = -10000;
 
    // Loop to find the maximum and
    // minimum adjacent element to
    // missing number
    for (let i = 0; i < n; i++)
    {
        if (i > 0 && arr[i] == -1 && arr[i - 1] != -1)
        {
            mn = Math.min(mn, arr[i - 1]);
            mx = Math.max(mx, arr[i - 1]);
        }
 
        if (i < (n - 1) && arr[i] == -1 &&
                        arr[i + 1] != -1)
        {
            mn = Math.min(mn, arr[i + 1]);
            mx = Math.max(mx, arr[i + 1]);
        }
    }
 
    let res = (mx + mn) / 2;
    return res;
}
 
// Driver Code
 
let n = 5;
let arr = [-1, 10, -1, 12, -1];
 
// Function Call
let res = missingnumber(n, arr);
 
document.write(res);
 
 
</script>


Output: 

11

 

Time Complexity: O(N) 
Auxiliary Space: O(1)
 



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads