Add missing numbers problem

Author: sudheerj

src/java1/algorithms/array/disappearedNumbers/DisappearedNumbers.java

@@ -0,0 +1,32 @@
+package java1.algorithms.array.disappearedNumbers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DisappearedNumbers {
+
+    private static List<Integer> findDisappearedNumbers(int[] nums){
+        for (int i = 0; i < nums.length; i++) {
+            int index = Math.abs(nums[i])-1;
+            if(nums[index]>0) {
+                nums[index] = -nums[index];
+            }
+        }
+
+        List<Integer> missingNumbers = new ArrayList<>();
+        for (int i = 0; i < nums.length; i++) {
+            if(nums[i] >0) {
+                missingNumbers.add(i+1);
+            }
+        }
+
+        return missingNumbers;
+    }
+    public static void main(String[] args) {
+        int[] nums1= new int[]{6, 3, 1, 5, 3, 7, 5};
+        int[] nums2= new int[]{1, 1};
+
+        System.out.println(findDisappearedNumbers(nums1));
+        System.out.println(findDisappearedNumbers(nums2));
+    }
+}

src/java1/algorithms/array/disappearedNumbers/DisappearedNumbers.md

@@ -0,0 +1,31 @@
+**Description:**
+Given an integer array `nums` of length `n` where `nums[i]` is in the range `[1, n]`,  find an array of all the integers in the range(`[1,n]`) that do not appear in given `nums` array. 
+
+**Note:** The solution needs to be done without an extra space.
+
+### Examples
+Example 1:
+
+Input: nums = [6, 3, 1, 5, 3, 7, 5]
+Output: [2,4]
+
+Example 2:
+
+Input: nums = [1,1],
+Output: [2]
+
+**Algorithmic Steps**
+This problem is solved with the help of array traversal and marking the available numbers. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `findDisappearedNumbers`, which accepts input array(`nums`) to find the disppeared numbers.
+   
+2. Iterate over given array(`num`), fetch the respective index(0 based) for absolute current value. If the number at the index position is positive, mark the number by negating it.
+
+3. Define an empty missing numbers array(`missingNumbers`).
+   
+4. Iterate over the input array again, add the next index position as missing number(`i+1`) to missing numbers array.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements in an array. This is because we need to iterate over all the elements at most twice for finding the missing numbers.
+ 
+It takes constant time complexity of `O(1)` due to no additional datastructure been used other than output array(not considered as extra memory).

src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.js

@@ -0,0 +1,23 @@
+function findDisappearedNumbers(nums){
+    for (let i = 0; i < nums.length; i++) {
+        const index = Math.abs(nums[i])-1;
+        if(nums[index]>0) {
+            nums[index] = -nums[index];
+        }
+    }
+
+    let missingNumbers = [];
+    for (let i = 0; i < nums.length; i++) {
+        if(nums[i] >0) {
+            missingNumbers.push(i+1);
+        }
+    }
+
+    return missingNumbers;
+}
+
+const nums1= [6, 3, 1, 5, 3, 7, 5];
+const nums2= [1,1];
+
+console.log(findDisappearedNumbers(nums1));
+console.log(findDisappearedNumbers(nums2));

src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.md

@@ -0,0 +1,31 @@
+**Description:**
+Given an integer array `nums` of length `n` where `nums[i]` is in the range `[1, n]`,  find an array of all the integers in the range(`[1,n]`) that do not appear in given `nums` array. 
+
+**Note:** The solution needs to be done without an extra space.
+
+### Examples
+Example 1:
+
+Input: nums = [6, 3, 1, 5, 3, 7, 5]
+Output: [2,4]
+
+Example 2:
+
+Input: nums = [1,1],
+Output: [2]
+
+**Algorithmic Steps**
+This problem is solved with the help of array traversal and marking the available numbers. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `findDisappearedNumbers`, which accepts input array(`nums`) to find the disppeared numbers.
+   
+2. Iterate over given array(`num`), fetch the respective index(0 based) for absolute current value. If the number at the index position is positive, mark the number by negating it.
+
+3. Define an empty missing numbers array(`missingNumbers`).
+   
+4. Iterate over the input array again, add the next index position as missing number(`i+1`) to missing numbers array.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements in an array. This is because we need to iterate over all the elements at most twice for finding the missing numbers.
+ 
+It takes constant time complexity of `O(1)` due to no additional datastructure been used other than output array(not considered as extra memory).