Skip to content
Related Articles

Related Articles

Improve Article
k-th missing element in sorted array
  • Difficulty Level : Medium
  • Last Updated : 04 Jun, 2021

Given an increasing sequence a[], we need to find the K-th missing contiguous element in the increasing sequence which is not present in the sequence. If no k-th missing element is there output -1. 

Examples : 

Input : a[] = {2, 3, 5, 9, 10};   
        k = 1;
Output : 4
Explanation: Missing Element in the increasing 
sequence are {4, 6, 7, 8}. So k-th missing element
is 4

Input : a[] = {2, 3, 5, 9, 10, 11, 12};       
        k = 4;
Output : 8
Explanation: missing element in the increasing 
sequence are {4, 6, 7, 8}  so k-th missing 
element is 8

Approach 1: Start iterating over the array elements, and for every element check if next element is consecutive or not, if not, then take difference between these two, and check if difference is greater than or equal to given k, then calculate ans = a[i] + count, else iterate for next element.

C++




#include <bits/stdc++.h>
using namespace std;
 
// Function to find k-th
// missing element
int missingK(int a[], int k,
             int n)
{
    int difference = 0,
        ans = 0, count = k;
    bool flag = 0;
     
    // interating over the array
    for(int i = 0 ; i < n - 1; i++)
    {  
        difference = 0;
         
        // check if i-th and
        // (i + 1)-th element
        // are not consecutive
        if ((a[i] + 1) != a[i + 1])
        {
             
            // save their difference
            difference +=
                (a[i + 1] - a[i]) - 1;
             
            // check for difference
            // and given k
            if (difference >= count)
                {
                    ans = a[i] + count;
                    flag = 1;
                    break;
                }
            else
                count -= difference;
        }
    }
     
    // if found
    if(flag)
        return ans;
    else
        return  -1;
}
 
// Driver code
int main()
{
    // Input array
    int a[] = {1, 5, 11, 19};
     
    // k-th missing element
    // to be found in the array
    int k = 11;
    int n = sizeof(a) / sizeof(a[0]);
     
    // calling function to
    // find missing element
    int missing = missingK(a, k, n);
     
    cout << missing << endl;
     
    return 0;
}

Java




// Java program to check for
// even or odd
import java.io.*;
import java.util.*;
  
public class GFG {
      
    // Function to find k-th
    // missing element
    static int missingK(int []a, int k,
                                 int n)
    {
        int difference = 0,
            ans = 0, count = k;
        boolean flag = false;
          
        // interating over the array
        for(int i = 0 ; i < n - 1; i++)
        {
            difference = 0;
              
            // check if i-th and
            // (i + 1)-th element
            // are not consecutive
            if ((a[i] + 1) != a[i + 1])
            {
                  
                // save their difference
                difference +=
                    (a[i + 1] - a[i]) - 1;
                  
                // check for difference
                // and given k
                if (difference >= count)
                    {
                        ans = a[i] + count;
                        flag = true;
                        break;
                    }
                else
                    count -= difference;
            }
        }
          
        // if found
        if(flag)
            return ans;
        else
            return -1;
    }
      
    // Driver code
    public static void main(String args[])
    {
          
        // Input array
        int []a = {1, 5, 11, 19};
          
        // k-th missing element
        // to be found in the array
        int k = 11;
        int n = a.length;
          
        // calling function to
        // find missing element
        int missing = missingK(a, k, n);
          
        System.out.print(missing);
    }
  
}
  
// This code is contributed by
// Manish Shaw (manishshaw1)

Python3




# Function to find k-th
# missing element
def missingK(a, k, n) :
 
    difference = 0
    ans = 0
    count = k
    flag = 0
     
    # interating over the array
    for i in range (0, n-1) :
        difference = 0
         
        # check if i-th and
        # (i + 1)-th element
        # are not consecutive
        if ((a[i] + 1) != a[i + 1]) :
         
             
            # save their difference
            difference += (a[i + 1] - a[i]) - 1
             
            # check for difference
            # and given k
            if (difference >= count) :
                    ans = a[i] + count
                    flag = 1
                    break
            else :
                count -= difference    
     
    # if found
    if(flag) :
        return ans
    else :
        return -1
 
# Driver code
# Input array
a = [1, 5, 11, 19]
 
# k-th missing element
# to be found in the array
k = 11
n = len(a)
 
# calling function to
# find missing element
missing = missingK(a, k, n)
 
print(missing)
 
# This code is contributed by
# Manish Shaw (manishshaw1)

C#




// C# program to check for
// even or odd
using System;
using System.Collections.Generic;
 
class GFG {
     
    // Function to find k-th
    // missing element
    static int missingK(int []a, int k,
                                 int n)
    {
        int difference = 0,
            ans = 0, count = k;
        bool flag = false;
         
        // interating over the array
        for(int i = 0 ; i < n - 1; i++)
        {
            difference = 0;
             
            // check if i-th and
            // (i + 1)-th element
            // are not consecutive
            if ((a[i] + 1) != a[i + 1])
            {
                 
                // save their difference
                difference +=
                    (a[i + 1] - a[i]) - 1;
                 
                // check for difference
                // and given k
                if (difference >= count)
                    {
                        ans = a[i] + count;
                        flag = true;
                        break;
                    }
                else
                    count -= difference;
            }
        }
         
        // if found
        if(flag)
            return ans;
        else
            return -1;
    }
     
    // Driver code
    public static void Main()
    {
         
        // Input array
        int []a = {1, 5, 11, 19};
         
        // k-th missing element
        // to be found in the array
        int k = 11;
        int n = a.Length;
         
        // calling function to
        // find missing element
        int missing = missingK(a, k, n);
         
        Console.Write(missing);
    }
 
}
 
// This code is contributed by
// Manish Shaw (manishshaw1)

PHP




<?php
// Function to find k-th
// missing element
function missingK(&$a, $k, $n)
{
    $difference = 0;
    $ans = 0;
    $count = $k;
    $flag = 0;
     
    // interating over the array
    for($i = 0 ; $i < $n - 1; $i++)
    {
        $difference = 0;
         
        // check if i-th and
        // (i + 1)-th element
        // are not consecutive
        if (($a[$i] + 1) != $a[$i + 1])
        {
             
            // save their difference
            $difference += ($a[$i + 1] -
                            $a[$i]) - 1;
             
            // check for difference
            // and given k
            if ($difference >= $count)
                {
                    $ans = $a[$i] + $count;
                    $flag = 1;
                    break;
                }
            else
                $count -= $difference;
        }
    }
     
    // if found
    if($flag)
        return $ans;
    else
        return -1;
}
 
// Driver Code
 
// Input array
$a = array(1, 5, 11, 19);
 
// k-th missing element
// to be found in the array
$k = 11;
$n = count($a);
 
// calling function to
// find missing element
$missing = missingK($a, $k, $n);
 
echo $missing;
 
// This code is contributed by Manish Shaw
// (manishshaw1)
?>

Javascript




<script>
     
// Javascript program to check for
// even or odd
 
// Function to find k-th
// missing element
function missingK(a, k, n)
{
    let difference = 0, ans = 0, count = k;
    let flag = false;
      
    // interating over the array
    for(let i = 0 ; i < n - 1; i++)
    {
        difference = 0;
          
        // Check if i-th and
        // (i + 1)-th element
        // are not consecutive
        if ((a[i] + 1) != a[i + 1])
        {
              
            // Save their difference
            difference += (a[i + 1] - a[i]) - 1;
              
            // Check for difference
            // and given k
            if (difference >= count)
            {
                ans = a[i] + count;
                flag = true;
                break;
            }
            else
                count -= difference;
        }
    }
     
    // If found
    if (flag)
        return ans;
    else
        return -1;
}
 
// Driver code
 
// Input array
let a = [ 1, 5, 11, 19 ];
 
// k-th missing element
// to be found in the array
let k = 11;
let n = a.length;
 
// Calling function to
// find missing element
let missing = missingK(a, k, n);
 
document.write(missing);
 
// This code is contributed by suresh07
   
</script>
Output
14

Time Complexity :O(n), where n is the number of elements in the array. 



Approach 2: 

Apply a binary search. Since the array is sorted we can find at any given index how many numbers are missing as arr[index] – (index+1). We would leverage this knowledge and apply binary search to narrow down our hunt to find that index from which getting the missing number is easier.

Below is the implementation of the above approach:

C++




// CPP program for above approach
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
 
// Function to find
// kth missing number
int missingK(vector<int>& arr, int k)
{
  int n = arr.size();
  int l = 0, u = n - 1, mid;
   
  while(l <= u)
  {
    mid = (l + u)/2;
     
    int numbers_less_than_mid = arr[mid] -
                                    (mid + 1);
     
    // If the total missing number
    // count is equal to k we can iterate
    // backwards for the first missing number
    // and that will be the answer.
    if(numbers_less_than_mid == k)
    {
       
      // To further optimize we check
      // if the previous element's
      // missing number count is equal
      // to k. Eg: arr = [4,5,6,7,8]
      // If you observe in the example array,
      // the total count of missing numbers for all
      // the indices are same, and we are
      // aiming to narrow down the
      // search window and achieve O(logn)
      // time complexity which
      // otherwise would've been O(n).
      if(mid > 0 && (arr[mid - 1] - (mid)) == k)
      {
        u = mid - 1;
        continue;
      }
      // Else we return arr[mid] - 1.
      return arr[mid]-1;
    }
     
    // Here we appropriately
    // narrow down the search window.
    if(numbers_less_than_mid < k)
    {
      l = mid + 1;
    }
    else if(k < numbers_less_than_mid)
    {
      u = mid - 1;
    }
  }
   
  // In case the upper limit is -ve
  // it means the missing number set
  // is 1,2,..,k and hence we directly return k.
  if(u < 0)
    return k;
   
  // Else we find the residual count
  // of numbers which we'd then add to
  // arr[u] and get the missing kth number.
  int less = arr[u] - (u + 1);
  k -= less;
   
  // Return arr[u] + k
  return arr[u] + k;
}
 
// Driver Code
int main()
{
    vector<int> arr = {2,3,4,7,11};
    int k = 5;
   
    // Function Call
    cout <<"Missing kth number = "<<
                        missingK(arr, k)<<endl;
    return 0;
}

Java




// Java program for above approach
public class GFG
{
 
  // Function to find
  // kth missing number
  static int missingK(int[] arr, int k)
  {
    int n = arr.length;
    int l = 0, u = n - 1, mid;   
    while(l <= u)
    {
      mid = (l + u)/2;       
      int numbers_less_than_mid = arr[mid] -
        (mid + 1);
 
      // If the total missing number
      // count is equal to k we can iterate
      // backwards for the first missing number
      // and that will be the answer.
      if(numbers_less_than_mid == k)
      {
 
        // To further optimize we check
        // if the previous element's
        // missing number count is equal
        // to k. Eg: arr = [4,5,6,7,8]
        // If you observe in the example array,
        // the total count of missing numbers for all
        // the indices are same, and we are
        // aiming to narrow down the
        // search window and achieve O(logn)
        // time complexity which
        // otherwise would've been O(n).
        if(mid > 0 && (arr[mid - 1] - (mid)) == k)
        {
          u = mid - 1;
          continue;
        }
 
        // Else we return arr[mid] - 1.
        return arr[mid] - 1;
      }
 
      // Here we appropriately
      // narrow down the search window.
      if(numbers_less_than_mid < k)
      {
        l = mid + 1;
      }
      else if(k < numbers_less_than_mid)
      {
        u = mid - 1;
      }
    }
 
    // In case the upper limit is -ve
    // it means the missing number set
    // is 1,2,..,k and hence we directly return k.
    if(u < 0)
      return k;
 
    // Else we find the residual count
    // of numbers which we'd then add to
    // arr[u] and get the missing kth number.
    int less = arr[u] - (u + 1);
    k -= less;
 
    // Return arr[u] + k
    return arr[u] + k;
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int[] arr = {2,3,4,7,11};
    int k = 5;
 
    // Function Call
    System.out.println("Missing kth number = "+ missingK(arr, k));
  }
}
 
// This code is contributed by divyesh072019.

Python3




# Python3 program for above approach
 
# Function to find
# kth missing number
def missingK(arr, k):
  n = len(arr)
  l = 0
  u = n - 1
  mid = 0
  while(l <= u):
    mid = (l + u)//2;
    numbers_less_than_mid = arr[mid] - (mid + 1);
     
    # If the total missing number
    # count is equal to k we can iterate
    # backwards for the first missing number
    # and that will be the answer.
    if(numbers_less_than_mid == k):
       
      # To further optimize we check
      # if the previous element's
      # missing number count is equal
      # to k. Eg: arr = [4,5,6,7,8]
      # If you observe in the example array,
      # the total count of missing numbers for all
      # the indices are same, and we are
      # aiming to narrow down the
      # search window and achieve O(logn)
      # time complexity which
      # otherwise would've been O(n).
      if(mid > 0 and (arr[mid - 1] - (mid)) == k):   
        u = mid - 1;
        continue;
       
      # Else we return arr[mid] - 1.
      return arr[mid]-1;
       
    # Here we appropriately
    # narrow down the search window.
    if(numbers_less_than_mid < k):   
      l = mid + 1;
    elif(k < numbers_less_than_mid):
      u = mid - 1;
 
  # In case the upper limit is -ve
  # it means the missing number set
  # is 1,2,..,k and hence we directly return k.
  if(u < 0):
    return k;
   
  # Else we find the residual count
  # of numbers which we'd then add to
  # arr[u] and get the missing kth number.
  less = arr[u] - (u + 1);
  k -= less;
   
  # Return arr[u] + k
  return arr[u] + k;
 
# Driver Code
if __name__=='__main__':
 
    arr = [2,3,4,7,11];
    k = 5;
   
    # Function Call
    print("Missing kth number = "+ str(missingK(arr, k)))
     
# This code is contributed by rutvik_56.

C#




// C# program for above approach
using System;
class GFG {
     
    // Function to find
    // kth missing number
    static int missingK(int[] arr, int k)
    {
      int n = arr.Length;
      int l = 0, u = n - 1, mid;
        
      while(l <= u)
      {
        mid = (l + u)/2;
          
        int numbers_less_than_mid = arr[mid] -
                                        (mid + 1);
          
        // If the total missing number
        // count is equal to k we can iterate
        // backwards for the first missing number
        // and that will be the answer.
        if(numbers_less_than_mid == k)
        {
            
          // To further optimize we check
          // if the previous element's
          // missing number count is equal
          // to k. Eg: arr = [4,5,6,7,8]
          // If you observe in the example array,
          // the total count of missing numbers for all
          // the indices are same, and we are
          // aiming to narrow down the
          // search window and achieve O(logn)
          // time complexity which
          // otherwise would've been O(n).
          if(mid > 0 && (arr[mid - 1] - (mid)) == k)
          {
            u = mid - 1;
            continue;
          }
           
          // Else we return arr[mid] - 1.
          return arr[mid] - 1;
        }
          
        // Here we appropriately
        // narrow down the search window.
        if(numbers_less_than_mid < k)
        {
          l = mid + 1;
        }
        else if(k < numbers_less_than_mid)
        {
          u = mid - 1;
        }
      }
        
      // In case the upper limit is -ve
      // it means the missing number set
      // is 1,2,..,k and hence we directly return k.
      if(u < 0)
        return k;
        
      // Else we find the residual count
      // of numbers which we'd then add to
      // arr[u] and get the missing kth number.
      int less = arr[u] - (u + 1);
      k -= less;
        
      // Return arr[u] + k
      return arr[u] + k;
    }
 
  // Driver code
  static void Main()
  {
    int[] arr = {2,3,4,7,11};
    int k = 5;
    
    // Function Call
    Console.WriteLine("Missing kth number = "+ missingK(arr, k));
  }
}
 
// This code is contributed by divyeshrabadiya07.
Output
Missing kth number = 9

Time Complexity: O(logn), where n is the number of elements in the array.

Approach 3 ( Using Map) : We will traverse the array and mark each of the element as visited in mapand we will also keep track of the min and max element present so that we know the lower and upper bound for  the given particular input. Then we start a loop from lower to upper bound and maintain a count variable . As soon we found a element which is not present in map we increment the count and until count becomes equal to k.

C++14




#include <iostream>
#include <unordered_map>
using namespace std;
 
int solve(int arr[] , int k , int n)
{
      unordered_map<int  ,int> umap;
      int mins = 99999;
      int maxs = -99999;
      for(int i=0 ; i<n ; i++)
    {
          umap[arr[i]] = 1; //mark each element of array in map
        if(mins > arr[i])
          mins = arr[i];  //keeping track of minimum element
        if(maxs < arr[i])
          maxs = arr[i]; //keeping track of maximum element i.e. upper bound
    }
      int counts = 0;
      //iterate from lower to upper bound
      for(int i=mins ; i<=maxs ; i++)
    {
          if(umap[i] == 0)
          counts++;
          if(counts == k)
          return i;
    }
      return -1;
}
int main() {
 
    int arr[] = {2, 3, 5, 9, 10, 11, 12} ;
      int k = 4;
      cout << solve(arr , k , 7) ; //(array , k , size of array)
    return 0;
}
Output
8

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes




My Personal Notes arrow_drop_up
Recommended Articles
Page :