Count of Missing Numbers in a sorted array
Last Updated :
19 Oct, 2023
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
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:
- Initialize a variable count to 0.
- Traverse the array from index 0 to N-2.
- If the difference between a[i+1] and a[i] is greater than 1, increment count by (a[i+1] - a[i] - 1).
- Print count as the number of missing elements in the array.
C++
#include <iostream>
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
import java.util.Arrays;
class GFG {
// This function displays the count of the missing numbers
public static void countMissingNum(int[] a, int N) {
int count = 0;
// Iterating over the array
for (int i = 0; i < N - 1; i++) {
// Checking if the consecutive number is not present
if (a[i + 1] != a[i] + 1) {
count += (a[i + 1] - a[i] - 1);
}
}
System.out.println(count);
}
// Driver code
public static void main(String[] args) {
int[] arr = { 5, 10, 20, 40 };
int N = arr.length;
// Function call
countMissingNum(arr, N);
}
}
# This function displays the count of the missing numbers
def CountMissingNum(a, N):
count = 0
# Iterating over the array
for i in range(N - 1):
# Checking if the consecutive number is not present
if a[i + 1] != a[i] + 1:
count += (a[i + 1] - a[i] - 1)
print(count)
# Driver code
arr = [5, 10, 20, 40]
N = len(arr)
# Function call
CountMissingNum(arr, N)
using System;
class GFG
{
// This function displays the count of the missing numbers
public static void CountMissingNum(int[] a, int N)
{
int count = 0;
// Iterating over the array
for (int i = 0; i < N - 1; i++)
{
// Checking if the consecutive number is not present
if (a[i + 1] != a[i] + 1)
{
count += (a[i + 1] - a[i] - 1);
}
}
Console.WriteLine(count);
}
// Driver code
public static void Main(string[] args)
{
int[] arr = { 5, 10, 20, 40 };
int N = arr.Length;
// Function call
CountMissingNum(arr, N);
}
}
// This function displays the count of the missing numbers
function CountMissingNum(a, N) {
let count = 0;
// Iterating over the array
for (let i = 0; i < N - 1; i++) {
// Checking if the consecutive number is not present
if (a[i + 1] !== a[i] + 1) {
count += (a[i + 1] - a[i] - 1);
}
}
console.log(count);
}
// Driver code
const arr = [5, 10, 20, 40];
const N = arr.length;
// Function call
CountMissingNum(arr, N);
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 <bits/stdc++.h>
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 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 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# 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
// 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
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 <iostream>
#include <unordered_set>
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;
}
import java.util.HashSet;
class GFG {
// Function to count the number of missing elements in a
// sorted array
public static int countMissingNumbers(int[] arr, int n) {
HashSet<Integer> hashSet = new HashSet<Integer>();
for (int i = 0; i < n; i++) {
hashSet.add(arr[i]);
}
int first = arr[0];
int last = arr[n - 1];
int count = 0;
for (int i = first; i <= last; i++) {
if (!hashSet.contains(i)) {
count++;
}
}
return count;
}
// Driver Code
public static void main(String[] args) {
int[] arr = { 5, 10, 20, 40 };
int n = arr.length;
System.out.println(countMissingNumbers(arr, n));
}
}
// by phasing17
# Function to count the number of missing elements in a
# sorted array
def countMissingNumbers(arr):
hashSet = set(arr)
first = arr[0]
last = arr[-1]
count = 0
for i in range(first, last + 1):
if i not in hashSet:
count += 1
return count
# Driver Code
if __name__ == "__main__":
arr = [5, 10, 20, 40]
n = len(arr)
print(countMissingNumbers(arr))
using System;
using System.Collections.Generic;
public class GFG
{
// Function to count the number of missing elements in a
// sorted array
public static int CountMissingNumbers(int[] arr, int n)
{
HashSet<int> hashSet = new HashSet<int>();
for (int i = 0; i < n; i++)
{
hashSet.Add(arr[i]);
}
int first = arr[0];
int last = arr[n - 1];
int count = 0;
for (int i = first; i <= last; i++)
{
if (!hashSet.Contains(i))
{
count++;
}
}
return count;
}
// Driver Code
public static void Main()
{
int[] arr = { 5, 10, 20, 40 };
int n = arr.Length;
Console.WriteLine(CountMissingNumbers(arr, n));
}
}
// by phasing17
function GFG(arr) {
// Create a Set to store the unique elements from
// the input array
const hashSet = new Set(arr);
const first = arr[0];
const last = arr[arr.length - 1];
let count = 0;
// Loop through the range of elements from
// first to last
for (let i = first; i <= last; i++) {
if (!hashSet.has(i)) {
count++;
}
}
// Return the count of missing elements
return count;
}
// Test the function with an example array
const arr = [5, 10, 20, 40];
console.log(GFG(arr));
Time Complexity: O(n)
Auxiliary Space: O(n)
Similar Reads
Missing in a Sorted Array of Natural Numbers Given a sorted array arr[] of n-1 integers, these integers are in the range of 1 to n. There are no duplicates in the array. One of the integers is missing in the array. Write an efficient code to find the missing integer. Examples: Input : arr[] = [1, 2, 3, 4, 6, 7, 8]Output : 5Explanation: The mis
12 min read
Find the only missing number in a sorted array You are given a sorted array of N integers from 1 to N with one number missing find the missing number Examples: Input :ar[] = {1, 3, 4, 5}Output : 2Input : ar[] = {1, 2, 3, 4, 5, 7, 8}Output : 6A simple solution is to linearly traverse the given array. Find the point where current element is not on
9 min read
Find missing element in a sorted array of consecutive numbers Given an array arr[] of n distinct integers. Elements are placed sequentially in ascending order with one element missing. The task is to find the missing element.Examples: Input: arr[] = {1, 2, 4, 5, 6, 7, 8, 9} Output: 3Input: arr[] = {-4, -3, -1, 0, 1, 2} Output: -2Input: arr[] = {1, 2, 3, 4} Out
7 min read
Kth Missing Positive Number in a Sorted Array Given a sorted array of distinct positive integers arr[] and integer k, the task is to find the kth positive number that is missing from arr[].Examples : Input: arr[] = [2, 3, 4, 7, 11], k = 5Output: 9Explanation: Missing are 1, 5, 6, 8, 9, 10, ... and 5th missing number is 9.Input: arr[] = [1, 2, 3
10 min read
Find all missing numbers from a given sorted array Given a sorted array arr[] of N integers, The task is to find the multiple missing elements in the array between the ranges [arr[0], arr[N-1]]. Examples: Input: arr[] = {6, 7, 10, 11, 13}Output: 8 9 12 Explanation: The elements of the array are present in the range of the maximum and minimum array e
13 min read
Find the missing number in a sorted array of limited range Given a sorted array of size n, consisting of integers from 1 to n+1 with one missing. The task is to find the missing element.Examples: Input : arr[] = [1, 3, 4, 5, 6]Output : 2Input : arr[] = [1, 2, 3, 4, 5, 7, 8, 9, 10]Output : 6Input: arr[] = [1, 2, 3, 4]Output: 5Using Linear Search - O(n) time
11 min read