diff --git a/Data Structures/Arrays/Missing_Number_in_Array.md b/Data Structures/Arrays/Missing_Number_in_Array.md
new file mode 100644
index 0000000..a31a7a6
--- /dev/null
+++ b/Data Structures/Arrays/Missing_Number_in_Array.md	
@@ -0,0 +1,102 @@
+# Missing Number in an Array
+
+## Problem :
+Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.
+
+## Example 1:
+Input: nums = [3,0,1]
+
+Output: 2
+### Explanation: 
+n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.
+## Example 2:
+Input: nums = [0,1]
+
+Output: 2
+### Explanation: 
+n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.
+## Example 3:
+Input: nums = [9,6,4,2,3,5,7,0,1]
+
+Output: 8
+### Explanation:
+n = 9 since there are 9 numbers, so all numbers are in the range [0,9]. 8 is the missing number in the range since it does not appear in nums.
+
+## Constraints:
+* n == nums.length
+* 1 <= n <= 104
+* 0 <= nums[i] <= n
+* All the numbers of nums are unique.
+
+## Approach :
+There are n unique numbers given.
+
+These values add up to ((n * (n + 1)) / 2)
+
+which is the same as adding the first n positive natural numbers together.
+
+This is equivalent to (array sum + missing number).
+
+SUM OF THE FIRST N NUMBERS - SUM OF ARRAY = Missing number.
+
+
+## Solution Function in Python :
+```python
+class Solution(object):
+    def missingNumber(self, nums):
+        n=len(nums)
+        # return the difference between the sum 
+        # and the total that is the missing number
+        return (n*(n+1)//2)-sum(nums)
+```
+
+## Solution Function in C++ :
+```cpp
+class Solution
+{
+public:
+    int missingNumber(vector<int>& nums)
+    {
+        int sum = 0;
+        int n = num.size();
+        int total = n*(n + 1)/2;
+        for (auto number : nums)
+        {
+            sum += number;
+        }
+        // return the difference between the sum and 
+        // the total that is the missing number
+        return total - sum;
+    }
+};
+```
+
+## Solution Function in java :
+```java
+class Solution 
+{
+    public int missingNumber(int[] nums)
+    {
+        int n = nums.length;
+        long sum = 0;
+        for (int i = 0 ; i < n ; i++)
+        {
+            sum += nums[i];
+        }
+        // return the difference between the sum and 
+        // the total that is the missing number
+        return (int)(((n*(n + 1))/2) - sum);
+    }
+ }
+```
+
+## Explanation :
+The Nth triangular number, which can be calculated as N * (N + 1) / 2, is the sum of all the numbers from 1 to N.
+
+Therefore, it seems to make sense that we can easily determine the missing number by comparing the Nth triangular number to the total of nums.
+
+## Time Complexity :
+Time Complexity is O(n).
+
+## Space Complexity :
+Space Complexity is O(1).