Add remove element algorithm

Author: sudheerj

README.md

@@ -55,6 +55,8 @@ List of Programs related to data structures and algorithms
 | 14  | First missing positive number         |     [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/14.firstMissingPositive/firstMissingPositive.js)     | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/14.firstMissingPositive/firstMissingPositive.js)         |     [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/14.firstMissingPositive/firstMissingPositive.md)     |  Hard  |       In-place hashing       |
 | 15  | Best time to buy stock and sell stock |             [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/15.buySellStock/buySellStock.js)             | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/15.buySellStock/buySellStock.js)                         |             [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/15.buySellStock/buySellStock.md)             |  Easy  |       Greedy algorithm       |
 | 16  | Two missing numbers                   |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/16.twoMissingNumbers/twoMissingNumbers.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/16.twoMissingNumbers/twoMissingNumbers.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/16.twoMissingNumbers/twoMissingNumbers.md)        | Medium | Sum and average calculations |
+| 17  | Pascal's Triangle                  |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/17.pascalsTriangle/pascalsTriangle.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/17.pascalsTriangle/pascalsTriangle.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/17.pascalsTriangle/pascalsTriangle.md)        | Easy | Array traversal and sequential sum |
+| 18  | Remove Element                   |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/18.removeElement/removeElement.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/18.removeElement/removeElement.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/18.removeElement/removeElement.md)        | Easy | Array traversal |
 
 ### String
 

src/java1/algorithms/array/removeElement/RemoveElement.java

@@ -0,0 +1,25 @@
+package java1.algorithms.array.removeElement;
+
+public class RemoveElement {
+
+    private static int removeElement(int[] nums, int val){
+        int k = 0;
+
+        for (int num : nums) {
+            if (num != val) {
+                nums[k] = num;
+                k++;
+            }
+        }
+
+        return k;
+    }
+    public static void main(String[] args) {
+        int[] nums1 = new int[]{4, 1, 1, 4, 1};
+        int val1=4;
+        System.out.println(removeElement(nums1, val1));
+        int[] nums2 = new int[]{0, 3, 5, 5, 3, 1, 5, 2};
+        int val2=5;
+        System.out.println(removeElement(nums2, val2));
+    }
+}

src/java1/algorithms/array/removeElement/RemoveElement.md

@@ -0,0 +1,29 @@
+**Description:**
+Given an array of integers `nums` and an integer `val`, remove all occurrences of `val` from `nums` in-place and return the number of elements which are not equals to `val`.
+
+### Examples
+Example 1:
+
+Input: nums = [4, 1, 1, 4, 1], val=4
+Output: 3
+
+Example 2:
+
+Input: nums = [0, 3, 5, 5, 3, 1, 5, 2], val=5
+Output: 5
+
+**Algorithmic Steps**
+This problem is solved with the help of iteration over an array. The algorithmic approach can be summarized as follows:
+
+1. Initialize the index variable(`k`) for position the elements of an array(`nums`) which are not equal to given value(i.e, `val`).
+
+2. Iterate over the array and compare each value with `val`. 
+
+3. If the current value is not equal to `val`, store the current value in kth position and increment the index variable(i.e, `k++`).
+
+4. After completion of iteration, the variable `k` indicates the number of elements which are not equal to given number.
+
+**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 once.
+ 
+It takes constant time complexity of `O(1)` due to no additional datastructure been used other than index variables.

src/javascript/algorithms/array/18.removeElement/removeElement.js

@@ -0,0 +1,18 @@
+function removeElement(nums, val){
+    let k=0;
+    for (const num of nums) {
+        if(num !== val) {
+            nums[k] = num;
+            k++;
+        }       
+    }
+
+    return k;
+}
+
+const nums1 = [4, 1, 1, 4, 1], val1=4;
+console.log(removeElement(nums1, val1));
+const nums2 = [0, 3, 5, 5, 3, 1, 5, 2], val2=5;
+console.log(removeElement(nums2, val2));
+
+

src/javascript/algorithms/array/18.removeElement/removeElement.md

@@ -0,0 +1,29 @@
+**Description:**
+Given an array of integers `nums` and an integer `val`, remove all occurrences of `val` from `nums` in-place and return the number of elements which are not equals to `val`.
+
+### Examples
+Example 1:
+
+Input: nums = [4, 1, 1, 4, 1], val=4
+Output: 3
+
+Example 2:
+
+Input: nums = [0, 3, 5, 5, 3, 1, 5, 2], val=5
+Output: 5
+
+**Algorithmic Steps**
+This problem is solved with the help of iteration over an array. The algorithmic approach can be summarized as follows:
+
+1. Initialize the index variable(`k`) for position the elements of an array(`nums`) which are not equal to given value(i.e, `val`).
+
+2. Iterate over the array and compare each value with `val`. 
+
+3. If the current value is not equal to `val`, store the current value in kth position and increment the index variable(i.e, `k++`).
+
+4. After completion of iteration, the variable `k` indicates the number of elements which are not equal to given number.
+
+**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 once.
+ 
+It takes constant time complexity of `O(1)` due to no additional datastructure been used other than index variables.