Skip to content
Related Articles

Related Articles

Count of missing elements from 1 to maximum in index range [L, R]

View Discussion
Improve Article
Save Article
  • Last Updated : 24 May, 2022

Given an array arr[] of length N, and an array queries[] of size Q, the task is to find the number of missing elements from 1 to maximum in the range of indices [L, R] where L is queries[i][0] and R is queries[i][1].

Examples:

Input: arr[] = {8, 6, 7, 7, 7}, queries = { {0, 3}, {1, 2}, {0, 2}, {1, 3}, {2, 3} }
Output: 5 5 5 5 6
Explanation: 
Maximum element for range [0, 3] is 8 so number of missing elements are 1, 2, 3, 4, 5.
Maximum element for range [1, 2] is 7 so number of missing elements are 1, 2, 3, 4, 5.
Maximum element for range [0, 2] is 8 so number of missing elements are 1, 2, 3, 4, 5.
Maximum element for range [1, 3] is 7 so number of missing elements are 1, 2, 3, 4, 5.
Maximum element for range [2, 3] is 7 so number of missing elements are 1, 2, 3, 4, 5, 6.

Input: arr[] = {2, 6, 4, 9}, queries = { {0, 3}, {1, 2}, {0, 2}, {1, 3}, {2, 3} }
Output: 5 4 3 6 7
Explanation: 
Maximum element for range [0, 3] is 9 so number of missing elements are 1, 3, 5, 7, 8.
Maximum element for range [1, 2] is 6 so number of missing elements are 1, 2, 3, 5.
Maximum element for range [0, 2] is 6 so number of missing elements are 1, 3, 5.
Maximum element for range [1, 3] is 9 so number of missing elements are 1, 2, 3, 5, 7, 8.
Maximum element for range [2, 3] is 9 so number of missing elements are 1, 2, 3, 5, 6, 7, 8.

 

Approach: One simple way is to process every query linearly, store all elements in a visited map and find the maximum element. Then return the number of missing elements from 1 to the maximum on that range. 

Follow the below steps to solve this problem:

  • Take one unordered map visited.
  • Traverse queries from i = 0 to Q-1.
    • Initialize one variable to store the maximum element of the given range.
    • Run again one for loop from queries[i][0] to queries[i][1].
      • Store the maximum element in this range.
      • Make the visited array 1 for each element visited in that range.
    • The number of missing elements is the same as the value of (maximum element – number of unique elements visited).

Below is the implementation of the above approach.

C++14




// C++ code to implement above approach.
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the number
// of missing element for each query
vector<int> SolveQMax(int* arr, int& n,
                      int queries[][2], int& q)
{
    // Initializing an unordered map
    unordered_map<int, bool> visited;
    int maxElement;
    vector<int> res;
 
    // Loop to find number of missing elements
    for (int i = 0; i < q; i++) {
        maxElement = INT_MIN;
        visited.clear();
        for (int j = queries[i][0];
             j <= queries[i][1]; j++) {
           
            // Finding the maximum value
            maxElement = max(maxElement,
                             arr[j]);
            visited[arr[j]] = 1;
        }
 
        res.push_back(maxElement
                      - visited.size());
    }
   
    // Return the answer
    return res
}
 
// Driver code
int main()
{
    int N = 5;
    int arr[] = { 8, 6, 7, 7, 7 };
    int Q = 5;
    int queries[][2] = { { 0, 3 }, { 1, 2 },
                         { 0, 2 }, { 1, 3 },
                         { 2, 3 } };
 
    // Function call
    SolveQMax(arr, N, queries, Q);
    return 0;
}


Java




// Java code to implement above approach.
import java.io.*;
import java.util.*;
 
class GFG {
    // Function to find the number
    // of missing element for each query
    public static ArrayList<Integer>
    SolveQMax(int arr[], int n, int queries[][], int q)
    {
        // Initializing an hashmap
        HashMap<Integer, Boolean> visited = new HashMap<>();
        int maxElement;
        ArrayList<Integer> res = new ArrayList<>();
 
        // Loop to find number of missing elements
        for (int i = 0; i < q; i++) {
            maxElement = Integer.MIN_VALUE;
            visited.clear();
            for (int j = queries[i][0]; j <= queries[i][1];
                 j++) {
 
                // Finding the maximum value
                maxElement = Math.max(maxElement, arr[j]);
                visited.put(arr[j], true);
            }
 
            res.add(maxElement - visited.size());
        }
 
        // Return the answer
        return res;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int N = 5;
        int arr[] = { 8, 6, 7, 7, 7 };
        int Q = 5;
        int queries[][] = {
            { 0, 3 }, { 1, 2 }, { 0, 2 }, { 1, 3 }, { 2, 3 }
        };
 
        // Function call
        System.out.print(SolveQMax(arr, N, queries, Q));
    }
}
 
// This code is contributed by Rohit Pradhan


Python3




# Python code to implement above approach.
 
INT_MIN = -2147483647 - 1
 
# Function to find the number
# of missing element for each query
def SolveQMax(arr, n, queries, q):
         
    # Initializing an unordered map
    visited = {}
    maxElement = INT_MIN
    res = []
 
    # Loop to find number of missing elements
    for i in range(q):
        maxElement = INT_MIN
        visited = {}
        for j in range(queries[i][0],queries[i][1]+1):
 
            # Finding the maximum value
            maxElement = max(maxElement,arr[j])
            visited[arr[j]] = 1
 
        # document.write(Object.keys(visited).length)
        res.append(maxElement - len(visited))
 
    # Return the answer
    return res
 
# Driver code
 
N = 5
arr = [8, 6, 7, 7, 7]
Q = 5
queries = [[0, 3], [1, 2],[0, 2], [1, 3],[2, 3]]
 
# Function call
print(SolveQMax(arr, N, queries, Q))
 
# This code is contributed by shinjanpatra


C#




// C# code to implement above approach.
using System;
using System.Collections.Generic;
 
class GFG
{
    // Function to find the number
    // of missing element for each query
    public static List<int> SolveQMax(int[] arr, int n,
                                      int[,] queries, int q)
    {
       
        // Initializing an hashmap
        Dictionary<int, Boolean> visited = new Dictionary<int, bool>();
        int maxElement;
        List<int> res = new List<int>();
 
        // Loop to find number of missing elements
        for (int i = 0; i < q; i++)
        {
            maxElement = int.MinValue;
            visited.Clear();
            for (int j = queries[i, 0]; j <= queries[i, 1];
                 j++)
            {
 
                // Finding the maximum value
                maxElement = Math.Max(maxElement, arr[j]);
                visited[arr[j]] = true;
            }
 
            res.Add(maxElement - visited.Count);
        }
 
        // Return the answer
        return res;
    }
 
    // Driver Code
    public static void Main()
    {
        int N = 5;
        int[] arr = { 8, 6, 7, 7, 7 };
        int Q = 5;
        int[,] queries = {
            { 0, 3 }, { 1, 2 }, { 0, 2 }, { 1, 3 }, { 2, 3 }
        };
 
        // Function call
        List<int> res = SolveQMax(arr, N, queries, Q);
 
        for (int i = 0; i < res.Count; i++)
        {
            Console.Write(res[i] + " ");
        }
    }
}
 
// This code is contributed by Saurbah Jaiswal


Javascript




<script>
    // JavaScript code to implement above approach.
    const INT_MIN = -2147483647 - 1;
 
    // Function to find the number
    // of missing element for each query
    const SolveQMax = (arr, n, queries, q) => {
     
        // Initializing an unordered map
        let visited = {};
        let maxElement = INT_MIN;
        let res = [];
 
        // Loop to find number of missing elements
        for (let i = 0; i < q; i++) {
            maxElement = INT_MIN;
            visited = {};
            for (let j = queries[i][0];
                j <= queries[i][1]; j++) {
 
                // Finding the maximum value
                maxElement = Math.max(maxElement,
                    arr[j]);
                visited[arr[j]] = 1;
            }
            // document.write(Object.keys(visited).length)
            res.push(maxElement
                - Object.keys(visited).length);
        }
 
        // Return the answer
        return res
    }
 
    // Driver code
 
    let N = 5;
    let arr = [8, 6, 7, 7, 7];
    let Q = 5;
    let queries = [[0, 3], [1, 2],
    [0, 2], [1, 3],
    [2, 3]];
 
    // Function call
    document.write(SolveQMax(arr, N, queries, Q));
 
// This code is contributed by rakeshsahni
 
</script>


Output

5 5 5 5 6 

Time Complexity: O(Q * N)
Auxiliary Space: O(N)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!