Minimum change in given value so that it lies in all given Ranges

Given an array of ranges arr[] of length N and a number D, the task is to find the minimum amount by which the number D sould be changed such that D lies in every range of given array. Here a range consists of two integer [start, end] and D is said to be inside of range, if start ≤ D ≤ end.

Examples:

Input: N = 3, D = 3
arr[] = {{0, 7}, {2, 14}, {4, 6}}
Output: 1
Explanation:
Here if we increment D by 1 then it will be inside of every range that is start ≤ D ≤ end.

Input: N = 2, D = 2
arr[] = {{1, 2}, {3, 2}}
Output: 0
Explanation:
Here D = 2 which is already inside of every range that is start ≤ D ≤ end.

Appproach:



Below is the code of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation find the minimum
// difference in the number D such that
// D is inside of every range
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the minimum
// difference in the number D such that
// D is inside of every range
void findMinimumOperation(int n, int d,
                      int arrays[3][2]){
    int cnt = 0;
    int first = INT_MIN, end = INT_MAX;
  
    // Loop to find the common range out 
    // of the given array of ranges.
    while (n--) {
          
        // Storing the start and end index
        int arr[2] = { arrays[cnt][0],
                        arrays[cnt][1] };
  
        // Sorting the range
        sort(arr, arr + 2);
  
        // Finding the maximum starting 
        // value of common segment
        first = max(first, arr[0]);
  
        // Finding the minimum ending 
        // value of common segment
        end = min(end, arr[1]);
        cnt++;
    }
  
    // If there is no common segment
    if (first > end)
        cout << "-1";
  
    else {
          
        // If the given number is between
        // the computed common range.
        if (d >= first && d <= end) {
            cout << "0";
        }
  
        // Finding the minimum distance
        else
            cout << min(abs(first - d),
                          abs(d - end));
    }
}
  
// Driver Code
int main()
{
    int n = 3, d = 3;
  
    // Given array of ranges
    int arrays[3][2] = {
        { 0, 7 },
        { 2, 14 },
        { 4, 6 }
    };
    findMinimumOperation(n, d, arrays);
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation find the minimum
// difference in the number D such that
// D is inside of every range
import java.util.*; 
  
class GFG
{
  
// Function to find the minimum
// difference in the number D such that
// D is inside of every range
static void findMinimumOperation(int n, int d,
                    int arrays[][]){
    int cnt = 0;
    int first = Integer.MIN_VALUE, end = Integer.MAX_VALUE;
  
    // Loop to find the common range out 
    // of the given array of ranges.
    while (n > 0) {
          
        // Storing the start and end index
        int arr[] = { arrays[cnt][0],
                        arrays[cnt][1] };
  
        // Sorting the range
        Arrays.sort(arr);
  
        // Finding the maximum starting 
        // value of common segment
        first = Math.max(first, arr[0]);
  
        // Finding the minimum ending 
        // value of common segment
        end = Math.min(end, arr[1]);
        cnt++;
        n--;
    }
  
    // If there is no common segment
    if (first > end)
        System.out.print("-1");
  
    else {
          
        // If the given number is between
        // the computed common range.
        if (d >= first && d <= end) {
            System.out.print("0");
        }
  
        // Finding the minimum distance
        else
            System.out.print(Math.min(Math.abs(first - d),
                        Math.abs(d - end)));
    }
}
  
// Driver Code
public static void main (String []args)
{
    int n = 3, d = 3;
  
    // Given array of ranges
    int arrays[][] = {
        { 0, 7 },
        { 2, 14 },
        { 4, 6 }
    };
    findMinimumOperation(n, d, arrays);
}
}
  
// This code is contributed by chitranayal
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation find the minimum
# difference in the number D such that
# D is inside of every range
  
# Function to find the minimum
# difference in the number D such that
# D is inside of every range
def findMinimumOperation(n, d,arrays):
    cnt = 0
    first = -10**9
    end = 10**9
  
    # Loop to find the common range out
    # of the given array of ranges.
    while (n):
  
        # Storing the start and end index
        arr = [arrays[cnt][0],arrays[cnt][1]]
  
        # Sorting the range
        arr = sorted(arr)
  
        # Finding the maximum starting
        # value of common segment
        first = max(first, arr[0])
  
        # Finding the minimum ending
        # value of common segment
        end = min(end, arr[1])
        cnt += 1
        n -= 1
  
    # If there is no common segment
    if (first > end):
        print("-1",end="")
  
    else:
  
        # If the given number is between
        # the computed common range.
        if (d >= first and d <= end):
            print("0",end="")
  
        # Finding the minimum distance
        else:
            print(min(abs(first - d),abs(d - end)),end="")
  
# Driver Code
if __name__ == '__main__':
    n = 3
    d = 3
  
    # Given array of ranges
    arrays=[[0, 7],
            [2, 14],
            [4, 6] ]
  
    findMinimumOperation(n, d, arrays)
  
# This code is contributed by mohit kumar 29    
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation find the minimum
// difference in the number D such that
// D is inside of every range
using System;
  
class GFG
{
   
// Function to find the minimum
// difference in the number D such that
// D is inside of every range
static void findMinimumOperation(int n, int d,
                    int [,]arrays){
    int cnt = 0;
    int first = int.MinValue, end = int.MaxValue;
   
    // Loop to find the common range out 
    // of the given array of ranges.
    while (n > 0) {
           
        // Storing the start and end index
        int []arr = { arrays[cnt, 0],
                        arrays[cnt, 1] };
   
        // Sorting the range
        Array.Sort(arr);
   
        // Finding the maximum starting 
        // value of common segment
        first = Math.Max(first, arr[0]);
   
        // Finding the minimum ending 
        // value of common segment
        end = Math.Min(end, arr[1]);
        cnt++;
        n--;
    }
   
    // If there is no common segment
    if (first > end)
        Console.Write("-1");
   
    else {
           
        // If the given number is between
        // the computed common range.
        if (d >= first && d <= end) {
            Console.Write("0");
        }
   
        // Finding the minimum distance
        else
            Console.Write(Math.Min(Math.Abs(first - d),
                        Math.Abs(d - end)));
    }
}
   
// Driver Code
public static void Main(String []args)
{
    int n = 3, d = 3;
   
    // Given array of ranges
    int [,]arrays = {
        { 0, 7 },
        { 2, 14 },
        { 4, 6 }
    };
    findMinimumOperation(n, d, arrays);
}
}
   
// This code is contributed by PrinciRaj1992
chevron_right

Output:
1





Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :
Practice Tags :