GeeksforGeeks App
Open App
Browser
Continue

# Count of Missing Numbers in a sorted array

Given a sorted array arr[], the task is to calculate the number of missing numbers between the first and last element of the sorted array. Examples:

Input: arr[] = { 1, 4, 5, 8 } Output: 4 Explanation: The missing integers in the array are {2, 3, 6, 7}. Therefore, the count is 4. Input: arr[] = {5, 10, 20, 40} Output: 32

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: The simplest approach to solve the problem is to iterate through the array and calculate the sum of all the adjacent differences of the elements of the array

Step by step algorithm:

1. Initialize a variable count to 0.
2. Traverse the array from index 0 to N-2.
3. If the difference between a[i+1] and a[i] is greater than 1, increment count by (a[i+1] – a[i] – 1).
4. Print count as the number of missing elements in the array.

## C++

 `#include ``using` `namespace` `std;` `void` `countMissingNum(``int` `a[], ``int` `N)``{``    ``int` `count = 0;``    ``for` `(``int` `i = 0; i < N - 1; i++) {``        ``if` `(a[i+1] != a[i] + 1) {``            ``count += (a[i+1] - a[i] - 1);``        ``}``    ``}``    ``cout << count << endl;``}` `int` `main()``{``    ``int` `arr[] = { 5, 10, 20, 40 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``countMissingNum(arr, N);``    ``return` `0;``}``//This code is contributed by Zaid Khan`

Output

`32`

Time Complexity:O(N)

Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to observe that the total count of numbers in the range of [arr[0], arr[N – 1]] is given by arr[N-1] – arr[0] + 1. Since the size of the array is N, the count of missing integers in the array is given by arr[N-1] – arr[0] + 1 – N. Below is the implementation of the above approach:

## C++

 `// C++ Program for the above approach``#include ``using` `namespace` `std;` `// Function that find the count of``// missing numbers in array a[]``void` `countMissingNum(``int` `a[], ``int` `N)``{``    ``// Calculate the count of missing``    ``// numbers in the array``    ``int` `count = a[N - 1] - a[0] + 1 - N;` `    ``cout << count << endl;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 5, 10, 20, 40 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``countMissingNum(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``class` `GFG{``    ` `// Function that find the count of``// missing numbers in array a[]``public` `static` `void` `countMissingNum(``int``[] a,``                                ``int` `N)``{``    ` `    ``// Calculate the count of missing``    ``// numbers in the array``    ``int` `count = a[N - ``1``] - a[``0``] + ``1` `- N;` `    ``System.out.println(count);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``5``, ``10``, ``20``, ``40` `};` `    ``int` `N = arr.length;` `    ``countMissingNum(arr, N);``}``}` `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program for the above approach` `# Function that find the count of``# missing numbers in array a[]``def` `countMissingNum(a, N):``    ` `    ``# Calculate the count of missing``    ``# numbers in the array``    ``count ``=` `a[N ``-` `1``] ``-` `a[``0``] ``+` `1` `-` `N` `    ``print``(count)` `# Driver Code``arr ``=` `[ ``5``, ``10``, ``20``, ``40` `]` `N ``=` `len``(arr)` `countMissingNum(arr, N)` `# This code is contributed by sanjoy_62`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `// Function that find the count of``// missing numbers in array a[]``public` `static` `void` `countMissingNum(``int``[] a,``                                ``int` `N)``{``    ` `    ``// Calculate the count of missing``    ``// numbers in the array``    ``int` `count = a[N - 1] - a[0] + 1 - N;` `    ``Console.Write(count);``}` `// Driver code``public` `static` `void` `Main(``string``[] args)``{``    ``int` `[]arr = { 5, 10, 20, 40 };``    ``int` `N = arr.Length;` `    ``countMissingNum(arr, N);``}``}` `// This code is contributed by rutvik_56`

## Javascript

 `// JS Program for the above approach` `// Function that find the count of``// missing numbers in array a[]``function` `countMissingNum(a, N)``{``    ``// Calculate the count of missing``    ``// numbers in the array``    ``let count = a[N - 1] - a[0] + 1 - N;` `    ``console.log(count);``}` `// Driver Code``let arr = [ 5, 10, 20, 40 ];``let N = arr.length;``countMissingNum(arr, N);` `// This code is contributed by phasing17`

Output

`32`

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

### Approach : Using Hashing

Steps:

• First, create a hash table.
• Insert all the elements of the array into it.
• After inserted all elements, iterate over the range of values between the first and last element of the array.
• If an element is not present in the hash table, then it is a missing number.
• Keep track of the count of missing numbers and return it as output.

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach` `#include ``#include ``using` `namespace` `std;` `// Function to count the number of missing elements in a``// sorted array``int` `countMissingNumbers(``int` `arr[], ``int` `n)``{``    ``unordered_set<``int``> hashSet;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``hashSet.insert(arr[i]);``    ``}``    ``int` `first = arr[0];``    ``int` `last = arr[n - 1];``    ``int` `count = 0;``    ``for` `(``int` `i = first; i <= last; i++) {``        ``if` `(hashSet.find(i) == hashSet.end()) {``            ``count++;``        ``}``    ``}``    ``return` `count;``}` `// Driver Code``int` `main()``{` `    ``int` `arr[] = { 5, 10, 20, 40 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << countMissingNumbers(arr, n) << endl;` `    ``return` `0;``}`

Output

```32
```

Time Complexity: O(n)

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up