Find the Nth number in the merged and sorted lists of given ranges

Given two integer array, L and R and an integer N. Each range from the given array denote that every number in the range [L[i], R[i]] is present. The task is to calculate the N-th(0-based indexing) element when numbers from given ranges are ordered in their sorted order.

Examples: 

Input: L = {1, 5}, R = {3, 7}, N = 4
Output: 6
Explanation: The numbers present are {1, 2, 3, 5, 6, 7}. Therefore 4-th element(0-indexed) is 6.

Input: L = {1, 3}, R = {4, 5}, N = 3
Output: 3
Explanation: The numbers present are {1, 2, 3, 4, 3, 4, 5} and their sorted order is {1, 2, 3, 3, 4, 4, 5}. Therefore 3-rd element(0-indexed) is 3.

Approach: The task can be solved with the help of a binary search over the answer. 
Follow the below steps to solve the problem:

• Calculate two variables min and max which store the minimum element from the L array and maximum element from the R array.
• The range of the binary search will be [min, max].
• For each mid = (min + max) / 2 calculate the position of the current element.
• To calculate the position, iterate over all ranges and make a variable t = 0 to store the position. Check below two conditions if L[i] >= mid
  • If mid <= R[i], update t += mid - L[i] + 1.
  • else t += R[i] - L[i] + 1
• The binary search range can be updated as
  • if(t > n) max = mid - 1.
  • else min = mid + 1.
• The final answer will be stored in the variable min.

Below is the implementation of the above approach: 

// C++ implementation for the above approach
#include <bits/stdc++.h>
using namespace std;
int nthElement(vector<int> L, vector<int> R, int n)
{
    // Store the size of the ranges
    int K = L.size();

    // Calculate the max and min values
    long long min = 2000000000, max = -2000000000;
    for (int i = 0; i < K; i++) {
        if (L[i] < min)
            min = L[i];
        if (R[i] > max)
            max = R[i];
    }

    // Do a binary search over answer
    while (min <= max) {
        long long mid = (min + max) / 2;
        long long t = 0;

        for (int i = 0; i < K; i++) {
            if (mid >= L[i]) {
                if (mid <= R[i]) {
                    t += mid - L[i] + 1;
                }
                else {
                    t += R[i] - L[i] + 1;
                }
            }
        }

        // Update the binary Search range.
        if (t > n) {
            max = mid - 1;
        }
        else {
            min = mid + 1;
        }
    }
    return min;
}

// Driver Code
int main()
{
    vector<int> L = { 1, 5 }, R = { 3, 7 };
    int N = 4;
    cout << nthElement(L, R, N);
}

// Java implementation for the above approach

class GFG {

    public static long nthElement(int[] L, int[] R, int n) {
        // Store the size of the ranges
        int K = L.length;

        // Calculate the max and min values
        long min = 2000000000, max = -2000000000;
        for (int i = 0; i < K; i++) {
            if (L[i] < min)
                min = L[i];
            if (R[i] > max)
                max = R[i];
        }

        // Do a binary search over answer
        while (min <= max) {
            long mid = (min + max) / 2;
            long t = 0;

            for (int i = 0; i < K; i++) {
                if (mid >= L[i]) {
                    if (mid <= R[i]) {
                        t += mid - L[i] + 1;
                    } else {
                        t += R[i] - L[i] + 1;
                    }
                }
            }

            // Update the binary Search range.
            if (t > n) {
                max = mid - 1;
            } else {
                min = mid + 1;
            }
        }
        return min;
    }

    // Driver Code
    public static void main(String args[]) {
        int[] L = { 1, 5 }, R = { 3, 7 };
        int N = 4;
        System.out.println(nthElement(L, R, N));
    }

}

// This code is contributed by gfgking

# Python implementation for the above approach

def nthElement(L, R, n):
  # Store the size of the ranges
  K = len(L)

  # Calculate the max and min values
  min = 2000000000 
  max = -2000000000;
  for i in range(K):
    if (L[i] < min):
      min = L[i]
    if (R[i] > max):
      max = R[i];
  

  # Do a binary search over answer
  while (min <= max):
    mid = (min + max) // 2;
    t = 0;

    for i in range(K):
      if (mid >= L[i]):
        if (mid <= R[i]):
          t += mid - L[i] + 1;
        else:
          t += R[i] - L[i] + 1;

    # Update the binary Search range.
    if (t > n):
      max = mid - 1;
    else:
      min = mid + 1;
    
  return min;

# Driver Code

L = [1, 5]
R = [3, 7];
N = 4;
print(nthElement(L, R, N));

# This code is contributed by gfgking

// C# implementation for the above approach

using System;
class GFG {

    public static long nthElement(int[] L, int[] R, int n)
    {
      
        // Store the size of the ranges
        int K = L.Length;

        // Calculate the max and min values
        long min = 2000000000, max = -2000000000;
        for (int i = 0; i < K; i++) {
            if (L[i] < min)
                min = L[i];
            if (R[i] > max)
                max = R[i];
        }

        // Do a binary search over answer
        while (min <= max) {
            long mid = (min + max) / 2;
            long t = 0;

            for (int i = 0; i < K; i++) {
                if (mid >= L[i]) {
                    if (mid <= R[i]) {
                        t += mid - L[i] + 1;
                    } else {
                        t += R[i] - L[i] + 1;
                    }
                }
            }

            // Update the binary Search range.
            if (t > n) {
                max = mid - 1;
            } else {
                min = mid + 1;
            }
        }
        return min;
    }

    // Driver Code
    public static void Main() {
        int[] L = { 1, 5 }, R = { 3, 7 };
        int N = 4;
        Console.Write(nthElement(L, R, N));
    }

}

// This code is contributed by gfgking

<script>
// Javascript implementation for the above approach

function nthElement(L, R, n) {
  // Store the size of the ranges
  let K = L.length;

  // Calculate the max and min values
  let min = 2000000000, max = -2000000000;
  for (let i = 0; i < K; i++) {
    if (L[i] < min)
      min = L[i];
    if (R[i] > max)
      max = R[i];
  }

  // Do a binary search over answer
  while (min <= max) {
    let mid = Math.floor((min + max) / 2);
    let t = 0;

    for (let i = 0; i < K; i++) {
      if (mid >= L[i]) {
        if (mid <= R[i]) {
          t += mid - L[i] + 1;
        }
        else {
          t += R[i] - L[i] + 1;
        }
      }
    }

    // Update the binary Search range.
    if (t > n) {
      max = mid - 1;
    }
    else {
      min = mid + 1;
    }
  }
  return min;
}

// Driver Code

let L = [1, 5]
let R = [3, 7];
let N = 4;
document.write(nthElement(L, R, N));

// This code is contributed by gfgking

</script>

6

Time Complexity: O(N*log(max - min))
Auxiliary Space: O(N)