algorithms updated

Author: sanjaydeveloper15

Arrays-Questions/duplicate-from-array.js

@@ -1,5 +1,6 @@
 let arr = [1, 2, 1, 3, 2, 1, 2, 3, 4, 5];
 
+// O(nSquare) due to .includes
 const getDuplicateFromArr = (inputArr) => {
     let resultArr = [];
     let obj = {};
@@ -15,4 +16,20 @@ const getDuplicateFromArr = (inputArr) => {
     return resultArr;
 }
 
-console.log(getDuplicateFromArr(arr));
+console.log(getDuplicateFromArr(arr));
+
+// O(n) due to Set has O(1)
+function getDuplicateFromArrOpt(inputArr) {
+    const duplicateSet = new Set();
+    const uniqueSet = new Set();
+    for (let i = 0; i < inputArr.length; i++) {
+        if (uniqueSet.has(inputArr[i])) {
+            duplicateSet.add(inputArr[i]);
+        } else {
+            uniqueSet.add(inputArr[i])
+        }
+    }
+    return duplicateSet;
+}
+
+console.log(getDuplicateFromArrOpt(arr))

Arrays-Questions/fibonacci-series.js

@@ -0,0 +1,16 @@
+/**
+ * The Fibonacci series is a sequence of numbers where each number is the sum of the two preceding ones, starting from 0 and 1.
+ * Formula: F(n)=F(n−1)+F(n−2)
+ * Example: 0,1,1,2,3,5,8,13,21,34,55,…
+ * Time Complexity O(n)
+ */
+
+const getFibbonaciSeries = ((tillNum) => {
+    const series = [0, 1]
+    for (let i = 2; i < tillNum; i++) {
+        series.push(series[series.length-1] + series[series.length-2])
+    }
+    return series
+});
+
+console.log(getFibbonaciSeries(10))

Arrays-Questions/insert-ele.js

@@ -0,0 +1,21 @@
+/**
+ * Q. Insert new element at 3rd position
+ * Time complexity O(n), cause using slice and splice methods due to element shifting
+ * Ideally linear search
+ */
+
+let arr = [1,2,4,5,6];
+let leftArr = arr.slice(0,2);
+let middleArr = [3]
+let rightArr = arr.slice(2)
+let resultArr = [];
+
+resultArr.push(...leftArr)
+resultArr.push(...middleArr)
+resultArr.push(...rightArr);
+
+console.log('slice',resultArr)
+
+// With splice
+arr.splice(2,0,3);
+console.log('splice one liner',arr)

Arrays-Questions/is-prime-number.js

@@ -1,4 +1,9 @@
-// Write a program for check number is prime or not ?
+/**
+ * Q. Write a program for check number is prime or not ?
+ * Only divisible by 1 or SELF only
+ * @param {number} inputNum 
+ * @returns {boolean}
+ */
 const isPrime = (inputNum) => {
     let result = true;
     for (let i = 2; i < inputNum; i++) {

Object-Questions/object-with-map.js

@@ -0,0 +1,19 @@
+/**
+ * Benefits of Map 
+ * 1. Faster with large datasets also
+ * 2. Ordered keys be default
+ */
+
+const map = new Map();
+map.set("name", "Sanjay");
+map.set("age", 27);
+map.set("designation", "Senior Consultant");
+
+console.log(map.get("name")); 
+
+// Iteration
+map.forEach((value, key) => {
+  console.log(`${key}: ${value}`);
+});
+
+console.log(Object.keys(map)) // Not works as it is Map not Object

Searching-Algos/binary-search.js

@@ -47,4 +47,27 @@ const binarySearch = (sortedNumArr, findVal) => {
 }
 
 console.log(binarySearch([1, 2, 3, 4, 5], 6)) // -1
-console.log(binarySearch([1, 3, 5, 6, 9, 14, 29, 57, 89], 29)); // 1
+console.log(binarySearch([1, 3, 5, 6, 9, 14, 29, 57, 89], 29)); // 1
+
+let arr = [1, 2, 3, 4, 10, 20, 31, 43, 51]
+
+function inArray(val) {
+    let result = false;
+    let leftIndex = 0, rightIndex = arr.length - 1, midIndex;
+    let count = 0;
+    while(leftIndex < rightIndex) {
+        midIndex = Math.round((leftIndex + rightIndex)/2)
+        if(arr[leftIndex] === val || arr[midIndex] === val || arr[rightIndex] === val) return true
+        if(midIndex === rightIndex) return false
+        if(val > arr[midIndex]) {
+            leftIndex = midIndex
+        } else {
+            rightIndex = midIndex
+        }
+        count ++
+        console.log(count)
+    }
+    return result;
+}
+
+console.log(inArray(43));

Sorting-Algos/bubble-sort.js

@@ -1,4 +1,6 @@
 // Custom sorting program in JS via Bubble Sort?
+// Time Complexity O(nSquare)
+// Space Complexity O(1)
 let unSortArr = [4, -1, 34, 9, -9, 103];
 
 const sortArr = (inputArr) => {
@@ -46,3 +48,42 @@ const sortArrOpt = (inputArr) => {
 };
 
 console.log(sortArrOpt(unSortArr));
+
+
+// Time Complexity: O(nSquare)
+function sortArrPlayGround(inputArr, type) {
+    // Step 1: validations checks
+    type = type.toLowerCase();
+    const validSortTypes = ['asc', 'desc'];
+    if (!Array.isArray(inputArr)) {
+        return 'Input parameter should be array only.';
+    }
+    if (!validSortTypes.includes(type)) {
+        return 'Sort type should be asc or desc only.';
+    }
+
+    // Step 2: start sorting algo
+    if(type === 'asc') {
+        for (let i = 0; i < inputArr.length; i++) {
+            for(let j = i + 1; j < inputArr.length; j++) {
+                if(inputArr[i] > inputArr[j]) {
+                    const tempEleVal = inputArr[i]
+                    inputArr[i] = inputArr[j];
+                    inputArr[j] = tempEleVal;
+                }
+            }
+        }
+    }
+    if(type === 'desc') {
+        for (let i = 0; i < inputArr.length; i++) {
+            for(let j = i + 1; j < inputArr.length; j++) {
+                if(inputArr[i] < inputArr[j]) {
+                    const tempEleVal = inputArr[i]
+                    inputArr[i] = inputArr[j];
+                    inputArr[j] = tempEleVal;
+                }
+            }
+        }
+    }
+    return inputArr;
+}