Find all missing numbers from a given sorted array
Last Updated :
08 Feb, 2022
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 element [6, 13]. Therefore, the total values will be {6, 7, 8, 9, 10, 11, 12, 13}.
The elements from the above range which are missing from the array are {8, 9, 12}.
Input: arr[] = {1, 2, 4, 6}
Output: 3 5
Naive Approach: The naive idea is to iterate over the difference between the consecutive pair of elements and the print all the numbers in this range if the difference is non-zero. Below are the steps:
- Initialize the variable diff which is equal to arr[0] - 0.
- Now traverse the array and see if the difference between arr[i] - i and diff is zero or not.
- If the difference is not equal to zero in the above steps, then the missing element is found.
- To find the multiple missing elements run a loop inside it and see if the diff is less than arr[i] - i then print the missing element i.e., i + diff.
- Now increment the diff as the difference is increased now.
- Repeat from step 2 until all the missing numbers are not found.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find the missing elements
void printMissingElements(int arr[], int N)
{
// Initialize diff
int diff = arr[0] - 0;
for (int i = 0; i < N; i++) {
// Check if diff and arr[i]-i
// both are equal or not
if (arr[i] - i != diff) {
// Loop for consecutive
// missing elements
while (diff < arr[i] - i) {
cout << i + diff << " ";
diff++;
}
}
}
}
// Driver Code
int main()
{
// Given array arr[]
int arr[] = { 6, 7, 10, 11, 13 };
int N = sizeof(arr) / sizeof(int);
// Function Call
printMissingElements(arr, N);
return 0;
}
// Java program for the above approach
import java.util.*;
class GFG{
// Function to find the missing elements
static void printMissingElements(int arr[],
int N)
{
// Initialize diff
int diff = arr[0] - 0;
for(int i = 0; i < N; i++)
{
// Check if diff and arr[i]-i
// both are equal or not
if (arr[i] - i != diff)
{
// Loop for consecutive
// missing elements
while (diff < arr[i] - i)
{
System.out.print((i + diff) + " ");
diff++;
}
}
}
}
// Driver Code
public static void main (String[] args)
{
// Given array arr[]
int arr[] = { 6, 7, 10, 11, 13 };
int N = arr.length;
// Function call
printMissingElements(arr, N);
}
}
// This code is contributed by offbeat
# Python3 program for the above approach
# Function to find the missing elements
def printMissingElements(arr, N):
# Initialize diff
diff = arr[0]
for i in range(N):
# Check if diff and arr[i]-i
# both are equal or not
if(arr[i] - i != diff):
# Loop for consecutive
# missing elements
while(diff < arr[i] - i):
print(i + diff, end = " ")
diff += 1
# Driver Code
# Given array arr[]
arr = [ 6, 7, 10, 11, 13 ]
N = len(arr)
# Function call
printMissingElements(arr, N)
# This code is contributed by Shivam Singh
// C# program for the above approach
using System;
class GFG{
// Function to find the missing elements
static void printMissingElements(int[] arr,
int N)
{
// Initialize diff
int diff = arr[0] - 0;
for(int i = 0; i < N; i++)
{
// Check if diff and arr[i]-i
// both are equal or not
if (arr[i] - i != diff)
{
// Loop for consecutive
// missing elements
while (diff < arr[i] - i)
{
Console.Write(i + diff + " ");
diff++;
}
}
}
}
// Driver code
static void Main()
{
// Given array arr[]
int[] arr = { 6, 7, 10, 11, 13 };
int N = arr.Length;
// Function call
printMissingElements(arr, N);
}
}
// This code is contributed by divyeshrabadiya07
<script>
// Javascript program to gather characters
// of a string in minimum cost
// Function to find the missing elements
function prletMissingElements(arr, N)
{
// Initialize diff
let diff = arr[0] - 0;
for(let i = 0; i < N; i++)
{
// Check if diff and arr[i]-i
// both are equal or not
if (arr[i] - i != diff)
{
// Loop for consecutive
// missing elements
while (diff < arr[i] - i)
{
document.write((i + diff) + " ");
diff++;
}
}
}
}
// Driver Code
// Given array arr[]
let arr = [ 6, 7, 10, 11, 13 ];
let N = arr.length;
// Function call
prletMissingElements(arr, N);
</script>
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient Approach: The idea is to use Hashing to optimize the above approach. Create a boolean array(say b[]) of size equal to the maximum element in the array and mark only those positions in the array b[] which are present in the given array. Print all the index in the array b[] that are not marked.
Below are the steps:
- Initialize a boolean array b[] with zero of size equals to the maximum element of the array.
- Iterate over the given array and mark for each element in the given array mark that index as true in the array b[].
- Now traverse the given array b[] from index arr[0] and print those index whose value is false as they are the element that is missing in the given array.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find the missing elements
void printMissingElements(int arr[], int N)
{
// Initialize an array with zero
// of size equals to the maximum
// element in the array
int b[arr[N - 1] + 1] = { 0 };
// Make b[i]=1 if i is present
// in the array
for (int i = 0; i < N; i++) {
// If the element is present
// make b[arr[i]]=1
b[arr[i]] = 1;
}
// Print the indices where b[i]=0
for (int i = arr[0]; i <= arr[N - 1]; i++) {
if (b[i] == 0) {
cout << i << " ";
}
}
}
// Driver Code
int main()
{
// Given array arr[]
int arr[] = { 6, 7, 10, 11, 13 };
int N = sizeof(arr) / sizeof(int);
// Function Call
printMissingElements(arr, N);
return 0;
}
// Java program for the above approach
import java.util.*;
class GFG{
// Function to find the missing elements
static void printMissingElements(int arr[],
int N)
{
// Initialize an array with zero
// of size equals to the maximum
// element in the array
int[] b = new int[arr[N - 1] + 1];
// Make b[i]=1 if i is present
// in the array
for(int i = 0; i < N; i++)
{
// If the element is present
// make b[arr[i]]=1
b[arr[i]] = 1;
}
// Print the indices where b[i]=0
for(int i = arr[0]; i <= arr[N - 1]; i++)
{
if (b[i] == 0)
{
System.out.print(i + " ");
}
}
}
// Driver Code
public static void main (String[] args)
{
// Given array arr[]
int arr[] = { 6, 7, 10, 11, 13 };
int N = arr.length;
// Function call
printMissingElements(arr, N);
}
}
// This code is contributed by offbeat
# Python3 program to implement
# the above approach
# Function to find the missing elements
def printMissingElements(arr, N):
# Initialize an array with zero
# of size equals to the maximum
# element in the array
b = [0] * (arr[N - 1] + 1)
# Make b[i]=1 if i is present
# in the array
for i in range(N):
# If the element is present
# make b[arr[i]]=1
b[arr[i]] = 1
# Print the indices where b[i]=0
for i in range(arr[0], arr[N - 1] + 1):
if(b[i] == 0):
print(i, end = " ")
# Driver Code
# Given array arr[]
arr = [ 6, 7, 10, 11, 13 ]
N = len(arr)
# Function call
printMissingElements(arr, N)
# This code is contributed by Shivam Singh
// C# program for
// the above approach
using System;
class GFG{
// Function to find the missing elements
static void printMissingElements(int []arr,
int N)
{
// Initialize an array with zero
// of size equals to the maximum
// element in the array
int[] b = new int[arr[N - 1] + 1];
// Make b[i]=1 if i is present
// in the array
for(int i = 0; i < N; i++)
{
// If the element is present
// make b[arr[i]]=1
b[arr[i]] = 1;
}
// Print the indices where b[i]=0
for(int i = arr[0]; i <= arr[N - 1];
i++)
{
if (b[i] == 0)
{
Console.Write(i + " ");
}
}
}
// Driver Code
public static void Main(String[] args)
{
// Given array []arr
int []arr = {6, 7, 10, 11, 13};
int N = arr.Length;
// Function call
printMissingElements(arr, N);
}
}
// This code is contributed by Princi Singh
<script>
// JavaScript program for the above approach
// Function to find the missing elements
function printMissingElements(arr, N)
{
// Initialize an array with zero
// of size equals to the maximum
// element in the array
let b = new Uint8Array(arr[N - 1] + 1);
// Make b[i]=1 if i is present
// in the array
for (let i = 0; i < N; i++) {
// If the element is present
// make b[arr[i]]=1
b[arr[i]] = 1;
}
// Print the indices where b[i]=0
for (let i = arr[0]; i <= arr[N - 1]; i++) {
if (b[i] == 0) {
document.write( i + " ");
}
}
}
// Driver Code
// Given array arr[]
let arr = [ 6, 7, 10, 11, 13 ];
let N = arr.length;
// Function Call
printMissingElements(arr, N);
//This code is contributed by Mayank Tyagi
</script>
Time Complexity: O(M), where M is the maximum element of the array.
Auxiliary Space: O(M)
Most Efficient And Simple Approach:
In below approach simple we create a variable (cnt) this variable keeps the track of element present in array
1. We need to traverse the arr[0] to arr[N] to find missing number between it.
2. In for loop if arr[cnt] match to current element then we do not print that element and skip that element because it is present in array
once we found element then we increment the cnt++ for pointing next element in array
3. In else part we just print the element which does not match or present in array
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find the missing elements
void printMissingElements(int arr[], int N)
{
int cnt = 0;
for (int i = arr[0]; i <= arr[N - 1]; i++) {
// Check if number is equal to the first element in
// given array if array element match skip it increment for next element
if (arr[cnt] == i) {
// Increment the count to check next element
cnt++;
}
else {
// Print missing number
cout << i << " ";
}
}
}
// Driver Code
int main()
{
// Given array arr[]
int arr[] = { 6, 7, 10, 11, 13 };
int N = sizeof(arr) / sizeof(arr[0]);
// Function Call
printMissingElements(arr, N);
return 0;
}
//This code is contributed by Kuldeep Kushwaha
//Java program for the above approach
import java.io.*;
class GFG {
// Function to find the missing elements
public static void printMissingElements(int arr[], int N)
{
int cnt = 0;
for (int i = arr[0]; i <= arr[N - 1]; i++)
{
// Check if number is equal to the first element in
// given array if array element match skip it increment for next element
if (arr[cnt] == i)
{
// Increment the count to check next element
cnt++;
}
else
{
// Print missing number
System.out.print(i + " ");
}
}
}
// Driver Code
public static void main (String[] args)
{
// Given array arr[]
int arr[] = { 6, 7, 10, 11, 13 };
int N = arr.length;
// Function Call
printMissingElements(arr, N);
}
}
// This code is contributed by Shubham Singh
# Python program for the above approach
# Function to find the missing elements
def printMissingElements(arr, N):
cnt = 0
for i in range(arr[0], arr[N - 1]+1):
# Check if number is equal to the first element in
# given array if array element match skip it increment for next element
if (arr[cnt] == i):
# Increment the count to check next element
cnt += 1
else:
# Print missing number
print(i , end = " ")
# Driver Code
# Given array arr[]
arr = [ 6, 7, 10, 11, 13 ]
N = len(arr)
# Function Call
printMissingElements(arr, N)
# This code is contributed by Shubham Singh
//C# program for the above approach
using System;
using System.Linq;
public class GFG{
// Function to find the missing elements
public static void printMissingElements(int[] arr, int N)
{
int cnt = 0;
for (int i = arr[0]; i <= arr[N - 1]; i++)
{
// Check if number is equal to the first element in
// given array if array element match skip it increment for next element
if (arr[cnt] == i)
{
// Increment the count to check next element
cnt++;
}
else
{
// Print missing number
Console.Write(i + " ");
}
}
}
// Driver Code
static public void Main ()
{
// Given array arr[]
int[] arr = { 6, 7, 10, 11, 13 };
int N = arr.Length;
// Function Call
printMissingElements(arr, N);
}
}
// This code is contributed by Shubham Singh
<script>
// Javascript program for the above approach
// Function to find the missing elements
function printMissingElements(arr, N)
{
var cnt = 0;
for (var i = arr[0]; i <= arr[N - 1]; i++) {
// Check if number is equal to the first element in
// given array if array element match skip it increment for next element
if (arr[cnt] == i)
{
// Increment the count to check next element
cnt++;
}
else
{
// Print missing number
document.write(i + " ");
}
}
}
// Driver Code
// Given array arr[]
var arr = [ 6, 7, 10, 11, 13 ];
var N = arr.length;
// Function Call
printMissingElements(arr, N);
// This code is contributed by Shubham Singh
</script>
Time Complexity: O(N), where N is the maximum element of the array.
Auxiliary Space: O(1) Because of this method the overflow of hash or extra space will be saved.
Similar Reads
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
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,
9 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 indices of a given element in sorted form of given Array
Given an array arr[] of integers of size N and a target value val. Your task is to find the indices of val in the array after sorting the array in increasing order. Note: The indices must be in increasing order. Examples: Input: arr = [1, 2, 5, 2, 3], val = 2Output: 1 2Explanation: After sorting, ar
6 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
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 first k natural numbers missing in given array
Given an array of size n and a number k, we need to print first k natural numbers that are not there in the given array. Examples: Input : [2 3 4] k = 3 Output : [1 5 6] Input : [-2 -3 4] k = 2 Output : [1 2]Recommended: Please solve it on “PRACTICE †first, before moving on to the solution. Sort th
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
Most Efficient Way to Find a Missing Number in an array
Have you wondered which is the most efficient way for a popular problem to find a missing Number? well in this post we are going to discuss this phenomenon in brief. First, let's discuss the problem statement: Given an array of numbers from 1 to N (both inclusive). The size of the array is N-1. The
7 min read
Find all good indices in the given Array
Given an array A[] of integers. The task is to print all indices i of this array such that after removing the ith element from the array, the array becomes a good array. Note: An array is good if there is an element in the array that equals to the sum of all other elements.1-based indexing is consid
6 min read