Skip to content

Finding the Missing Number in a Sequence of Consecutive Integers in Python

Updated: at 02:50 AM

Finding a missing number in a sequence of consecutive integers is a common coding interview question used to test a candidate’s logic, mathematical, and Python programming skills. This question evaluates whether the candidate can implement an algorithm to efficiently determine the missing number, without using built-in functions.

In this comprehensive guide, we will examine different methods to solve this technical interview question using Python. We will look at techniques like a mathematical formula, brute force, hash sets, XOR bit manipulation, and mathematical summation - explaining each approach with clear examples and Python code snippets. The advantages and limitations of each method are also analyzed.

Table of Contents

Open Table of Contents

Defining the Problem:

Given an unsorted array ‘arr’ containing consecutive integers from 1 to n, with one number missing, the task is to find the missing number in Python.

For example:

arr = [2, 4, 1, 5]

Here, n = 5, and the numbers from 1 to 5 are 2, 4, 1, 5. So the missing number is 3.

The key aspects of this problem are:

Method 1: Mathematical Formula

A simple mathematical formula can be derived to find the missing number:

Missing Number = Total Sum of Numbers - Sum of Array Elements


Total Sum of Numbers from 1 to n = n(n+1)/2

To find the missing number using this formula in Python:

def findMissingNumber(arr, n):

  # Calculate the expected sum
  total = n * (n+1) // 2

  # Calculate the sum of array elements
  sum_arr = sum(arr)

  # Missing number is the difference between the totals
  return total - sum_arr

arr = [2, 4, 1, 5]
n = len(arr)+1

print(findMissingNumber(arr, n))

# Output: 3



Method 2: Brute Force

The brute force technique involves iterating over the numbers from 1 to n, checking if each number is present in the array using linear search. The missing number is the one not found in the array.

def findMissingBruteForce(arr, n):

  for i in range(1, n+1):
    if i not in arr:
      return i

arr = [2, 4, 1, 5]
n = len(arr)+1

print(findMissingBruteForce(arr, n))

# Output: 3



Method 3: Using a Hash Set

We can utilize a hash set to keep track of the numbers seen so far. Iterate over the array, adding each element to the hash set. Finally, iterate from 1 to n and print the number not present in the set.

from typing import List

def findMissingHash(arr: List[int], n: int) -> int:

  # Hash set to store array elements
  seen = set()

  for num in arr:

  # Find missing number
  for i in range(1, n+1):
    if i not in seen:
      return i

arr = [2, 4, 1, 5]
n = len(arr) + 1

print(findMissingHash(arr, n))

# Output: 3



Method 4: Using XOR Bit Manipulation

XOR bit manipulation can be leveraged to find the missing number in O(n) time and O(1) extra space.

The key idea is that XOR of a number with itself is 0. And XOR is associative and commutative.

def findMissingXOR(arr, n):

  missing = n * (n+1) // 2

  for num in arr:
    missing ^= num

  return missing

Here, we first calculate the XOR of numbers from 1 to n. This can be mathematically derived to n * (n+1) // 2.

Then we XOR this result with each number in the array. The result will be the XOR of the missing number.

Since XOR is commutative and associative, the duplicate numbers will zero out. And we will be left with XOR of just the missing number.


Arr = [1, 5, 2, 6, 4]
n = 6

missing = 6 * (6 + 1) // 2 = 21
missing ^= 1 ^ 5 ^ 2 ^ 6 ^ 4
= 21 ^ 1 ^ 5 ^ 2 ^ 6 ^ 4
= 3



Method 5: Mathematical Summation

We can find the missing number by calculating the sum of numbers from 1 to n, and subtracting the sum of array elements.

def findMissingSum(arr, n):

  total = (n * (n + 1)) // 2

  sum_arr = 0
  for num in arr:
    sum_arr += num

  return total - sum_arr

This avoids overflow for larger values of n, compared to method 1.



Based on the above analysis, the recommended approaches are:

The best method depends on the specific problem constraints and performance requirements.

Handling Duplicates and Multiple Missing Numbers

The above solutions rely on the numbers being consecutive from 1 to n without duplicates. But we may encounter cases where:

  1. The array has duplicate elements.

  2. There are multiple missing numbers.

Here are two techniques to handle these scenarios:

1. Using a Hash Set

We can store all array elements in a hash set. Iterate from 1 to n and print all numbers not present in the set.

This will work seamlessly for both duplicate elements and multiple missing numbers.

def findMissingDuplicates(arr, n):

  # Hash set for array elements
  seen = set(arr)

  # Find all missing numbers
  missing = []
  for i in range(1, n+1):
    if i not in seen:

  return missing


2. Sorting the Array

If the array is sorted, we can traverse the array and find missing elements by comparing consecutive elements:

def findMissingSorted(arr, n):

  missing = []

  # Sort the array

  # Compare consecutive elements
  prev = arr[0]
  for i in range(1, len(arr)):
    if arr[i] - prev > 1:
      missing.append(prev + 1)

    prev = arr[i]

  # Check for missing number after last element
  if prev != n:
    missing.append(prev + 1)

  return missing

This modifies the input array.


Therefore, using a hash set is preferred for handling duplicates and multiple missing numbers.

Variations of the Problem

Some variations of the missing number problem that you may encounter are:

1. Cyclic Array: The numbers form a cyclic sequence from 1 to n.

For example: arr = [5, 4, 2, 1] and n = 4

Solution: Find the sum of numbers and array elements. The difference is the missing number.

2. Large Sequence: The sequence length n is very large (in billions).

Solution: Use mathematical summation approach to avoid integer overflow.

3. Continous Sequence: The numbers are in a continous sequence but not starting from 1.

For example: arr = [101, 102, 103, 105]

Solution: Maintain the difference between consecutive elements to find the missing number.

4. Duplicates Allowed: The array may contain duplicate elements.

Solution: Use a hash set to store unique elements as discussed above.

5. Multiple Missing Numbers: There can be more than one missing number in the sequence.

Solution: Find missing numbers iteratively using hash set or sorting approaches.

Practical Applications

The techniques to find missing elements in a sequence have several real-world applications:


To summarize, here are the key points on how to find the missing number in a sequence of consecutive integers in Python:

By mastering these algorithms and being able to code the solutions efficiently in Python, you can successfully tackle the “find missing number” problem in coding interviews and data analysis tasks in the real world.