Python | Find missing numbers in a sorted list range

Given a range of sorted list of integers with some integers missing in between, write a Python program to find all the missing integers. 

Examples:

Input : [1, 2, 4, 6, 7, 9, 10]
Output : [3, 5, 8]

Input : [5, 6, 10, 11, 13]
Output : [7, 8, 9, 12]

Method #1: List comprehension 

Python3

# Python3 program to Find missing
# integers in list

def find_missing(lst):
    max = lst[0]
    for i in lst :
      if i > max :
        max= i

    min = lst [0]
    for i in lst :
      if i < min:
        min = i
    missing = max+1
    list1=[]

    for _ in lst :

        max = max -1
        if max not in lst :
          list1.append(max)






    return list1

# Driver code
lst = [1,5,4,6,8, 2,3, 7, 9, 10]
print(find_missing(lst))

Output:

[3, 5, 8]

Time Complexity: O(N)

Auxiliary Space: O(1)

Method #2: List comprehension using zip()

Python3

# Python3 program to Find missing
# integers in list

def find_missing(lst):
    return [i for x, y in zip(lst, lst[1:])
        for i in range(x + 1, y) if y - x > 1]

# Driver code
lst = [1, 2, 4, 6, 7, 9, 10]
print(find_missing(lst))

Output:

[3, 5, 8]

Time Complexity: O(N)

Auxiliary Space: O(1)

Method #3: Using set The use of Python set is an efficient and tricky way to find the missing numbers in the list. We convert the list to set and simply output the difference between this set and a set that contains integers ranging from min(lst) and max(lst). 

Python3

# Python3 program to Find missing
# integers in list

def find_missing(lst):
    return sorted(set(range(lst[0], lst[-1])) - set(lst))

# Driver code
lst = [1, 2, 4, 6, 7, 9, 10]
print(find_missing(lst))

Output:

[3, 5, 8]

Time Complexity: O(NlogN)

Auxiliary Space: O(N)

Method #4: Using difference() This is a similar approach to the previous one with a slight difference that instead of using ‘-‘ operator to find the difference between both the sets, we can use Python difference() method. 

Python3

# Python3 program to Find missing
# integers in list

def find_missing(lst):
    start = lst[0]
    end = lst[-1]
    return sorted(set(range(start, end + 1)).difference(lst))

# Driver code
lst = [1, 2, 4, 6, 7, 9, 10]
print(find_missing(lst))

Output:

[3, 5, 8]

Time Complexity: O(N)

Auxiliary Space: O(N)

Method#5: Using Recursive method.

Python3

# Function to find missing integers
def find_missing_recursive(lst, start, end):
    if start > end:
        return []
    if start not in lst:
        return [start] + find_missing_recursive(lst, start + 1, end)
    return find_missing_recursive(lst, start + 1, end)

# Driver code
lst = [1, 2, 4, 6, 7, 9, 10]
start = lst[0]
end = lst[-1]
print(find_missing_recursive(lst, start, end))
#this code contributed by tvsk.

Output

[3, 5, 8]

Time Complexity: O(n)

Auxiliary Space: O(n)

 Method#6: Using a dictionary to count the frequency of each integer in the list, then checking which integers are missing

Python3

def find_missing(lst):
    # Create a frequency dictionary with keys ranging from the minimum to maximum value in the list
    freq_dict = {i:0 for i in range(min(lst), max(lst)+1)}

    # Iterate through the list and increment the frequency count for each value encountered
    for i in lst:
        freq_dict[i] += 1

    # Return a list of all keys with frequency 0 (i.e., the missing values)
    return [key for key, val in freq_dict.items() if val == 0]

# Example usage
lst = [1, 2, 4, 6, 7, 9, 10]
missing = find_missing(lst)
print("The original list: ", lst)
print("The missing elements: ", missing)

Output

The original list:  [1, 2, 4, 6, 7, 9, 10]
The missing elements:  [3, 5, 8]

Time Complexity: O(n)

Auxiliary Space: O(n)

 Method#7: Using set difference and itertools module: 

 Algorithm:

1.Define a function named ‘find_missing’ that takes a list as input.
2.Initialize a set that contains all integers between the minimum and maximum values of the input list.
3.Subtract the set containing the input list from the set created in step 2 to get the missing integers.
4.Sort the result and return it.

Python3

import itertools

def find_missing(lst):
    return sorted(set(range(lst[0], lst[-1])) - set(lst))

lst = [1, 2, 4, 6, 7, 9, 10]
print("The original list: ", lst)
print("The missing elements: ", find_missing(lst))

#This code is contributed by Jyothi pinjala

Output

The original list:  [1, 2, 4, 6, 7, 9, 10]
The missing elements:  [3, 5, 8]

Time Complexity:
The time complexity of this algorithm is O(n log n), where n is the length of the input list. The set operations take O(n) time in the worst case, and sorting the resulting set takes O(n log n) time.

Auxiliary Space:
The space complexity of this algorithm is O(n), where n is the length of the input list. This is because we are creating a set that contains all integers between the minimum and maximum values of the input list.

Method#7: Using numpy’s setdiff1d() function

Algorithm:

• Import the numpy library using import numpy as np
• Define a function find_missing that takes a list as input
• Convert the list to a numpy array using np.array(lst)
• Create a range of values between the minimum and maximum value in the list using np.arange(lst[0], lst[-1]+1)
• Use numpy’s setdiff1d() function to calculate the missing values between the full range and the converted array
• Convert the numpy array of missing values back to a list using missing.tolist()
• Return the list of missing values from the function
  Call the function using a list as input
• Print the original list and the missing elements list

Python3

#importing the numpy library
import numpy as np
def find_missing(lst):
    # Converting the list to numpy array
    arr = np.array(lst)
    # Creating a range of values between the minimum and maximum value in the list
    full_range = np.arange(lst[0], lst[-1]+1)
    # Calculating the missing values using numpy's setdiff1d() function
    missing = np.setdiff1d(full_range, arr)
    # Converting the numpy array back to a list and returning it
    return missing.tolist()
#Example usage
lst = [1, 2, 4, 6, 7, 9, 10]
missing = find_missing(lst)
print("The original list: ", lst)
print("The missing elements: ", missing)

Output:
The original list: [1, 2, 4, 6, 7, 9, 10]
The missing elements: [3, 5, 8]

Time Complexity: O(NlogN) (due to sorting in setdiff1d())

Auxiliary Space: O(N)