# Find the Missing Number

• Difficulty Level : Easy
• Last Updated : 21 Jun, 2022

You are given a list of n-1 integers and these integers are in the range of 1 to n. There are no duplicates in the list. One of the integers is missing from the list. Write an efficient code to find the missing integer.
Example:

Input: arr[] = {1, 2, 4, 6, 3, 7, 8}
Output: 5
Explanation: The missing number between 1 to 8 is 5

Input: arr[] = {1, 2, 3, 5}
Output: 4
Explanation: The missing number between 1 to 5 is 4

Method 1: This method uses the technique of the Summation formula.

• Approach: The length of the array is n-1. So, the sum of all n elements i.e. sum of numbers from 1 to n can be calculated using the formula n*(n+1)/2. Now find the sum of all the elements in the array and subtract it from the sum of the first n natural numbers, it will give us the value of the missing element.
• Algorithm:
1. Calculate the sum of the first n natural numbers as sumtotal= n*(n+1)/2
2. Create a variable sum to store the sum of the array elements.
3. Traverse the array from start to end.
4. Update the value of sum as sum = sum + array[i]
5. Print the missing number as SumTotal – sum

Below is the implementation of the above approach:

## C++14

 `#include ``using` `namespace` `std;`` ` `// Function to get the missing number``int` `getMissingNo(``int` `a[], ``int` `n)``{`` ` `    ``int` `total = (n + 1) * (n + 2) / 2;``    ``for` `(``int` `i = 0; i < n; i++)``        ``total -= a[i];``    ``return` `total;``}`` ` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 4, 5, 6 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `miss = getMissingNo(arr, n);``    ``cout << miss;``}`

## C

 `#include `` ` `/* getMissingNo takes array and size of array as arguments*/``int` `getMissingNo(``int` `a[], ``int` `n)``{``    ``int` `i, total;``    ``total = (n + 1) * (n + 2) / 2;``    ``for` `(i = 0; i < n; i++)``        ``total -= a[i];``    ``return` `total;``}`` ` `/*program to test above function */``int` `main()``{``    ``int` `a[] = { 1, 2, 4, 5, 6 };``    ``int` `miss = getMissingNo(a, 5);``    ``printf``(``"%d"``, miss);``    ``getchar``();``}`

## Java

 `// Java program to find missing Number``import` `java.util.*;``import` `java.util.Arrays;``class` `GFG {``    ``public` `static` `int``    ``findDisappearedNumbers(``int``[] nums)``    ``{``        ``int` `n=nums.length;``        ``int` `sum=((n+``1``)*(n+``2``))/``2``;``        ``for``(``int` `i=``0``;i

## Python

 `# getMissingNo takes list as argument``def` `getMissingNo(A):``    ``n ``=` `len``(A)``    ``total ``=` `(n ``+` `1``)``*``(n ``+` `2``)``/``2``    ``sum_of_A ``=` `sum``(A)``    ``return` `total ``-` `sum_of_A`` ` ` ` `# Driver program to test the above function``A ``=` `[``1``, ``2``, ``4``, ``5``, ``6``]``miss ``=` `getMissingNo(A)``print``(miss)``# This code is contributed by Pratik Chhajer`

## C#

 `// C# program to find missing Number``using` `System;`` ` `class` `GFG {``    ``// Function to ind missing number``    ``static` `int` `getMissingNo(``int``[] a, ``int` `n)``    ``{``        ``int` `total = (n + 1) * (n + 2) / 2;`` ` `        ``for` `(``int` `i = 0; i < n; i++)``            ``total -= a[i];`` ` `        ``return` `total;``    ``}`` ` `    ``/* program to test above function */``    ``public` `static` `void` `Main()``    ``{``        ``int``[] a = { 1, 2, 4, 5, 6 };``        ``int` `miss = getMissingNo(a, 5);``        ``Console.Write(miss);``    ``}``}`` ` `// This code is contributed by Sam007_`

## PHP

 ``

## Javascript

 ``

Output

`3`

Complexity Analysis:

• Time Complexity: O(n).
Only one traversal of the array is needed.
• Space Complexity: O(1).
No extra space is needed

Modification for Overflow :
Approach: The approach remains the same but there can be an overflow if n is large. In order to avoid integer overflow, pick one number from the known numbers and subtract that one number from the given numbers. This way there won’t be any Integer Overflow.

Algorithm:

1. Create a variable sum = 1 which will store the missing number and a counter variable c = 2.
2. Traverse the array from start to end.
3. Update the value of sum as sum = sum – array[i] + c and increment c as c++.
4. Print the missing number as a sum. Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;`` ` `int` `getMissingNo(``int` `a[], ``int` `n)``{``    ``int` `i, total = 1;`` ` `    ``for` `(i = 2; i <= (n + 1); i++) {``        ``total += i;``        ``total -= a[i - 2];``    ``}``    ``return` `total;``}`` ` `// Driver Program``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 5 };``    ``cout << getMissingNo(arr, ``sizeof``(arr) / ``sizeof``(arr));``    ``return` `0;``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `#include `` ` `int` `getMissingNo(``int` `a[], ``int` `n)``{``    ``int` `i, total = 1;`` ` `    ``for` `(i = 2; i <= (n + 1); i++) {``        ``total += i;``        ``total -= a[i - 2];``    ``}``    ``return` `total;``}`` ` `// Driver Program``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 5 };``    ``printf``(``"%d"``,getMissingNo(arr, ``sizeof``(arr) / ``sizeof``(arr)));``    ``return` `0;``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java implementation``class` `GFG {``    ``static` `int` `getMissingNo(``int` `a[], ``int` `n)``    ``{``        ``int` `total = ``1``;``        ``for` `(``int` `i = ``2``; i <= (n + ``1``); i++) {``            ``total += i;``            ``total -= a[i - ``2``];``        ``}``        ``return` `total;``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``1``, ``2``, ``3``, ``5` `};``        ``System.out.println(getMissingNo(arr, arr.length));``    ``}``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# a represents the array``# n : Number of elements in array a``def` `getMissingNo(a, n): ``    ``i, total ``=` `0``, ``1`` ` `    ``for` `i ``in` `range``(``2``, n ``+` `2``):``        ``total ``+``=` `i``        ``total ``-``=` `a[i ``-` `2``]``    ``return` `total`` ` `# Driver Code``arr ``=` `[``1``, ``2``, ``3``, ``5``]``print``(getMissingNo(arr, ``len``(arr)))`` ` `# This code is contributed by Mohit kumar`

## C#

 `using` `System;`` ` `class` `GFG``{``     ` `// a represents the array``// n : Number of elements in array a``static` `int` `getMissingNo(``int``[] a, ``int` `n) ``{ ``    ``int` `i, total = 1; ``     ` `    ``for` `( i = 2; i <= (n + 1); i++)``    ``{``        ``total += i;``        ``total -= a[i - 2];``    ``}``    ``return` `total; ``} `` ` `// Driver Code``public` `static` `void` `Main() ``{``    ``int``[] arr = {1, 2, 3, 5};``    ``Console.Write(getMissingNo(arr, (arr.Length)));`` ` `    ``// Console.Write(getMissingNo(arr, 4));``}``}``// This code is contributed by SoumikMondal`

## Javascript

 ``

Output

`4`

Complexity Analysis:

• Time Complexity: O(n).
Only one traversal of the array is needed.
• Space Complexity: O(1).
No extra space is needed

Thanks to Sahil Rally for suggesting this improvement.
Method 2: This method uses the technique of XOR to solve the problem.

Approach:
XOR has certain properties

• Assume a1 ^ a2 ^ a3 ^ …^ an = a and a1 ^ a2 ^ a3 ^ …^ an-1 = b
• Then a ^ b = an

Algorithm:

1. Create two variables a = 0 and b = 0
2. Run a loop from 1 to n with i as counter.
3. For every index, update a as a = a ^ i
4. Now traverse the array from start to end.
5. For every index, update b as b = b ^ array[i].
6. Print the missing number as a ^ b.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;`` ` `// Function to get the missing number``int` `getMissingNo(``int` `a[], ``int` `n)``{``    ``// For xor of all the elements in array``    ``int` `x1 = a;`` ` `    ``// For xor of all the elements from 1 to n+1``    ``int` `x2 = 1;`` ` `    ``for` `(``int` `i = 1; i < n; i++)``        ``x1 = x1 ^ a[i];`` ` `    ``for` `(``int` `i = 2; i <= n + 1; i++)``        ``x2 = x2 ^ i;`` ` `    ``return` `(x1 ^ x2);``}`` ` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 4, 5, 6 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `miss = getMissingNo(arr, n);``    ``cout << miss;``}`

## C

 `#include `` ` `/* getMissingNo takes array and size of array as arguments*/``int` `getMissingNo(``int` `a[], ``int` `n)``{``    ``int` `i;``    ``int` `x1 = a; ``/* For xor of all the elements in array */``    ``int` `x2 = 1; ``/* For xor of all the elements from 1 to n+1 */`` ` `    ``for` `(i = 1; i < n; i++)``        ``x1 = x1 ^ a[i];`` ` `    ``for` `(i = 2; i <= n + 1; i++)``        ``x2 = x2 ^ i;`` ` `    ``return` `(x1 ^ x2);``}`` ` `/*program to test above function */``int` `main()``{``    ``int` `a[] = { 1, 2, 4, 5, 6 };``    ``int` `miss = getMissingNo(a, 5);``    ``printf``(``"%d"``, miss);``    ``getchar``();``}`

## Java

 `// Java program to find missing Number``// using xor``class` `Main {``    ``// Function to find missing number``    ``static` `int` `getMissingNo(``int` `a[], ``int` `n)``    ``{``        ``int` `x1 = a[``0``];``        ``int` `x2 = ``1``;`` ` `        ``/* For xor of all the elements ``           ``in array */``        ``for` `(``int` `i = ``1``; i < n; i++)``            ``x1 = x1 ^ a[i];`` ` `        ``/* For xor of all the elements ``           ``from 1 to n+1 */``        ``for` `(``int` `i = ``2``; i <= n + ``1``; i++)``            ``x2 = x2 ^ i;`` ` `        ``return` `(x1 ^ x2);``    ``}`` ` `    ``/* program to test above function */``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `a[] = { ``1``, ``2``, ``4``, ``5``, ``6` `};``        ``int` `miss = getMissingNo(a, ``5``);``        ``System.out.println(miss);``    ``}``}`

## Python3

 `# Python3 program to find``# the missing Number``# getMissingNo takes list as argument `` ` `def` `getMissingNo(a, n):``    ``x1 ``=` `a[``0``]``    ``x2 ``=` `1``     ` `    ``for` `i ``in` `range``(``1``, n):``        ``x1 ``=` `x1 ^ a[i]``         ` `    ``for` `i ``in` `range``(``2``, n ``+` `2``):``        ``x2 ``=` `x2 ^ i``     ` `    ``return` `x1 ^ x2`` ` ` ` `# Driver program to test above function``if` `__name__``=``=``'__main__'``:`` ` `    ``a ``=` `[``1``, ``2``, ``4``, ``5``, ``6``]``    ``n ``=` `len``(a)``    ``miss ``=` `getMissingNo(a, n) ``    ``print``(miss)``     ` `# This code is contributed by Yatin Gupta `

## C#

 `// C# program to find missing Number``// using xor``using` `System;`` ` `class` `GFG {``    ``// Function to find missing number``    ``static` `int` `getMissingNo(``int``[] a, ``int` `n)``    ``{``        ``int` `x1 = a;``        ``int` `x2 = 1;`` ` `        ``/* For xor of all the elements ``        ``in array */``        ``for` `(``int` `i = 1; i < n; i++)``            ``x1 = x1 ^ a[i];`` ` `        ``/* For xor of all the elements ``        ``from 1 to n+1 */``        ``for` `(``int` `i = 2; i <= n + 1; i++)``            ``x2 = x2 ^ i;`` ` `        ``return` `(x1 ^ x2);``    ``}`` ` `    ``/* driver program to test above function */``    ``public` `static` `void` `Main()``    ``{``        ``int``[] a = { 1, 2, 4, 5, 6 };``        ``int` `miss = getMissingNo(a, 5);``        ``Console.Write(miss);``    ``}``}`` ` `// This code is contributed by Sam007_`

## PHP

 ``

## Javascript

 ``

Output

`3`

Complexity Analysis:

• Time Complexity: O(n).
Only one traversal of the array is needed.
• Space Complexity: O(1).
No extra space is needed.

Method 3: This method will work only in python.
Approach:
Take the sum of all elements in the array and subtract that from the sum of n+1 elements. For Eg:
If my elements are li=[1,2,4,5] then take the sum of all elements in li and subtract it from the sum of len(li)+1 elements. The following code shows the demonstration.

## C++

 `// C++ program to find the missing Number``#include ``using` `namespace` `std;`` ` `// getMissingNo takes list as argument``int` `getMissingNo(``int` `a[], ``int` `n)``{``    ``int` `n_elements_sum = n * (n + 1) / 2;``    ``int` `sum = 0;`` ` `    ``for` `(``int` `i = 0; i < n - 1; i++)``        ``sum += a[i];``    ``return` `n_elements_sum - sum;``}`` ` `// Driver code``int` `main()``{``    ``int` `a[] = { 1, 2, 4, 5, 6 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a) + 1;``    ``int` `miss = getMissingNo(a, n);``    ``cout << (miss);``    ``return` `0;``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to find the missing Number``#include `` ` `// getMissingNo takes list as argument``int` `getMissingNo(``int` `a[], ``int` `n)``{``    ``int` `n_elements_sum = n * (n + 1) / 2;``    ``int` `sum = 0;`` ` `    ``for` `(``int` `i = 0; i < n - 1; i++)``        ``sum += a[i];``    ``return` `n_elements_sum - sum;``}`` ` `// Driver code``int` `main()``{``    ``int` `a[] = { 1, 2, 4, 5, 6 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a) + 1;``    ``int` `miss = getMissingNo(a, n);``    ``printf``(``"%d"``,miss);``    ``return` `0;``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program to find the missing Number``class` `GFG {`` ` `    ``// getMissingNo function for finding missing number``    ``static` `int` `getMissingNo(``int` `a[], ``int` `n)``    ``{``        ``int` `n_elements_sum = n * (n + ``1``) / ``2``;``        ``int` `sum = ``0``;`` ` `        ``for` `(``int` `i = ``0``; i < n - ``1``; i++)``            ``sum += a[i];`` ` `        ``return` `n_elements_sum - sum;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `a[] = { ``1``, ``2``, ``4``, ``5``, ``6` `};``        ``int` `n = a.length + ``1``;``        ``int` `miss = getMissingNo(a, n);`` ` `        ``System.out.print(miss);``    ``}``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# Python3 program to find``# the missing Number``# getMissingNo takes list as argument ``def` `getMissingNo(a, n):``    ``n_elements_sum``=``n``*``(n``+``1``)``/``/``2``    ``return` `n_elements_sum``-``sum``(a)`` ` ` ` `# Driver program to test above function``if` `__name__``=``=``'__main__'``:`` ` `    ``a ``=` `[``1``, ``2``, ``4``, ``5``, ``6``]``    ``n ``=` `len``(a)``+``1``    ``miss ``=` `getMissingNo(a, n) ``    ``print``(miss)`

## C#

 `// C# program to implement ``// the above approach``using` `System; ``class` `GFG{ ``   ` `// Function to find missing ``// number ``static` `int` `getMissingNo(``int``[] a, ``                        ``int` `n) ``{ ``  ``int` `n_elements_sum = (n * (n + 1) / 2);``  ``int` `sum = 0; `` ` `  ``for` `(``int` `i = 0; i < n - 1; i++) ``    ``sum = sum + a[i]; `` ` `  ``return` `(n_elements_sum - sum); ``} `` ` `// Driver code``public` `static` `void` `Main() ``{ ``  ``int``[] a = {1, 2, 4, 5, 6}; ``  ``int` `miss = getMissingNo(a, 5); ``  ``Console.Write(miss); ``} ``} `` ` `// This code is contributed by Virusbuddah`

## Javascript

 ``

Output

`3`

Time Complexity: O(n)
Auxiliary Space: O(1)

Method 4: Efficient Approach using (Cyclic Sort)
Approach: All the given array numbers are sorted and in the range of 1 to n-1. If the range is 1 to N  then every array element will be at the location, index == value-1 i.e. means at the 0th index value will be 1 similarly at the 1st index position value will be 2 and so on till nth value.

Below is the implementation of the above approach:

## Java

 `// java program to check missingNo``import` `java.util.*;``public` `class` `MissingNumber {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``1``, ``2``, ``4``, ``5``, ``6` `};``        ``int` `n = arr.length;``        ``int` `ans = getMissingNo(arr, n);``        ``System.out.println(ans);``    ``}`` ` `    ``static` `int` `getMissingNo(``int``[] arr, ``int` `n)``    ``{``        ``int` `i = ``0``;``        ``while` `(i < n) {``            ``// as array is of 1 based indexing so the``            ``// correct position or index number of each``            ``// element is element-1 i.e. 1 will be at 0th``            ``// index similarly 2 correct index will 1 so``            ``// on...``            ``int` `correctpos = arr[i] - ``1``;``            ``if` `(arr[i] < n && arr[i] != arr[correctpos]) {``                ``// if array element should be lesser than``                ``// size and array element should not be at``                ``// its correct postion then only swap with``                ``// its correct positioin or index value``                ``swap(arr, i, correctpos);``            ``}``            ``else` `{``                ``// if element is at its correct position``                ``// just increment i and check for remaining``                ``// array elements``                ``i++;``            ``}``        ``}``      ``// check for missing elemnt by comparing elements with their index values ``        ``for` `(``int` `index = ``0``; index < arr.length; index++) {``            ``if` `(arr[index] != index + ``1``) {``                ``return` `index + ``1``;``            ``}``        ``}``        ``return` `arr.length;``    ``}`` ` `    ``static` `void` `swap(``int``[] arr, ``int` `i, ``int` `correctpos)``    ``{``      ``// swap elements with their correct indexes``        ``int` `temp = arr[i];``        ``arr[i] = arr[correctpos];``        ``arr[correctpos] = temp;``    ``}``}``// this code is contributed by devendra solunke`

## Python3

 `# Python3 program to check missingNo``def` `getMissingNo(arr, n) :``    ``i ``=` `0``;``     ` `    ``while` `(i < n) :``        ``# as array is of 1 based indexing so the``        ``# correct position or index number of each``        ``# element is element-1 i.e. 1 will be at 0th``        ``# index similarly 2 correct index will 1 so``        ``# on...``        ``correctpos ``=` `arr[i] ``-` `1``;``        ``if` `(arr[i] < n ``and` `arr[i] !``=` `arr[correctpos]) :``            ``# if array element should be lesser than``            ``# size and array element should not be at``            ``# its correct postion then only swap with``            ``# its correct positioin or index value``            ``arr[i],arr[correctpos] ``=` `arr[correctpos], arr[i]`` ` `        ``else` `:``            ``# if element is at its correct position``            ``# just increment i and check for remaining``            ``# array elements``            ``i ``+``=` `1``;``             ` `    ``# check for missing elemnt by comparing elements with their index values ``    ``for` `index ``in` `range``(n) : ``        ``if` `(arr[index] !``=` `index ``+` `1``) :``            ``return` `index ``+` `1``;``             ` `    ``return` `n;`` ` `if` `__name__ ``=``=` `"__main__"` `:``    ``arr ``=` `[ ``1``, ``2``, ``4``, ``5``, ``6` `];``    ``n ``=` `len``(arr);``    ``print``(getMissingNo(arr, n));`` ` ` ` `    ``# This Code is Contributed by AnkThon`

## C#

 `// C# program to implement``// the above approach``using` `System;``class` `GFG {`` ` `    ``// Function to find missing``    ``// number``    ``static` `int` `getMissingNo(``int``[] arr, ``int` `n)``    ``{``        ``int` `i = 0;``        ``while` `(i < n) {``            ``// as array is of 1 based indexing so the``            ``// correct position or index number of each``            ``// element is element-1 i.e. 1 will be at 0th``            ``// index similarly 2 correct index will 1 so``            ``// on...``            ``int` `correctpos = arr[i] - 1;``            ``if` `(arr[i] < n && arr[i] != arr[correctpos]) {``                ``// if array element should be lesser than``                ``// size and array element should not be at``                ``// its correct postion then only swap with``                ``// its correct positioin or index value``                ``swap(arr, i, correctpos);``            ``}``            ``else` `{``                ``// if element is at its correct position``                ``// just increment i and check for remaining``                ``// array elements``                ``i++;``            ``}``        ``}``        ``// check for missing elemnt by comparing elements``        ``// with their index values``        ``for` `(``int` `index = 0; index < n; index++) {``            ``if` `(arr[index] != index + 1) {``                ``return` `index + 1;``            ``}``        ``}``        ``return` `n;``    ``}`` ` `    ``static` `void` `swap(``int``[] arr, ``int` `i, ``int` `correctpos)``    ``{``        ``// swap elements with their correct indexes``        ``int` `temp = arr[i];``        ``arr[i] = arr[correctpos];``        ``arr[correctpos] = temp;``    ``}``    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 1, 2, 4, 5, 6 };``        ``int` `n = arr.Length;``        ``int` `ans = getMissingNo(arr, n);``        ``Console.Write(ans);``    ``}``}`` ` `// This code is contributed by devendra solunke`

## Javascript

 `// javascript program to check missingNo````// this code is contributed by devendra solunke`

Output

`3`

Time Complexity: O(N) requires (n-1) comparisons, so -1 is constant hence we can eliminate it, and the remaining n is complexity for the Best Case.

If an array is not sorted it will be the worst case for an algorithm and it will take O(N2) complexity. let’s see how we can calculate worst-case complexity.

1 + 2 + 3 + 4 . . . . . .  . . . .  (n-1) comparisons will required so the sum of all natural numbers can be calculated using n*(n+1)/2. Hence we can conclude that time complexity is N

Space Complexity: O( 1)