Added DS & Algo in JS

Author: Imam Hossain Santho

DS & Algo/create-a-queue-class.js

@@ -0,0 +1,38 @@
+/*Data Structures: Create a Queue Class */
+class Queue{
+  constructor(){
+    this.queue = [];
+    this.back = 0;
+    this.top = 0;
+  }
+  enqueue(val){
+    this.queue[this.top++] = val;
+  }
+  dequeue(){
+    return this.queue[this.back++];
+  }
+  front(){
+    return this.queue[this.back];
+  }
+  size(){
+    return this.top - this.back; 
+  }
+  isEmpty(){
+    return this.back>=this.top;
+  }
+  print(){
+    console.log(this.queue);
+  }
+}
+
+let q = new Queue();
+console.log(q.isEmpty()); //true
+q.enqueue(20);
+console.log(q.isEmpty()); //false
+q.enqueue(30);
+console.log(q.dequeue()); //20
+console.log(q.front()); //30
+console.log(q.size());
+q.dequeue();
+console.log(q.isEmpty()); //true
+

DS & Algo/create-a-stack-class.js

@@ -0,0 +1,35 @@
+//Data Structures: Create a Stack Class
+
+class Stack{
+  constructor(){
+    this.stack = [];
+  }
+  print(){
+    console.log(this.stack);
+  }
+  push(val){
+    return this.stack.push(val);
+  }
+  pop(){
+    return this.stack.pop();
+  }
+  peek(){
+    return this.stack[this.stack.length -1];
+  }
+  isEmpty(){
+    return this.stack.length === 0;
+  }
+  clear(){
+    return (this.stack.length = 0);
+  }
+}
+let st = new Stack();
+console.log(st);
+st.push(10);
+st.push(20);
+st.push(15);
+console.log(st); //{ stack: [ 10, 20, 15 ] }
+st.pop();
+console.log(st.peek()); //20
+st.clear();
+console.log(st.isEmpty()); //true

DS & Algo/find-the-symmetric-difference.js

@@ -0,0 +1,22 @@
+/*
+Algorithms: Find the Symmetric Difference
+Create a function that takes two or more arrays and returns an array of the symmetric difference (△ or ⊕) of the provided arrays.
+
+Given two sets (for example set A = {1, 2, 3} and set B = {2, 3, 4}), the mathematical term "symmetric difference" of two sets is the set of elements which are in either of the two sets, but not in both (A △ B = C = {1, 4}). For every additional symmetric difference you take (say on a set D = {2, 3}), you should get the set with elements which are in either of the two the sets but not both (C △ D = {1, 4} △ {2, 3} = {1, 2, 3, 4}). The resulting array must contain only unique values (no duplicates).
+*/
+
+function sym(...args) {
+  //removing duplicates from each array
+  args = args.map(item => [...new Set(item)]);
+  //return intersection set of the two arrays
+  const reducer = (acc, curr) => [
+    ...acc.filter(item => !curr.includes(item)),
+    ...curr.filter(item=> !acc.includes(item))
+  ];
+  let result = args.reduce(reducer);
+  
+  console.log(result);
+  return result;
+}
+
+sym([1, 2, 3], [5, 2, 1, 4, 5]);

DS & Algo/implement-bubble-sort.js

@@ -0,0 +1,16 @@
+/*Algorithms: Implement Bubble Sort */
+function bubbleSort(arr) {
+  // change code below this line
+  for(let i=0; i<arr.length; i++){
+    for(let j=i+1; j<arr.length; j++){
+      if(arr[j]<arr[i]){
+        [arr[j], arr[i]] = [arr[i], arr[j]]; //swap here
+      }
+    }
+  }
+  console.log(arr);
+  return arr;
+  // change code above this line
+}
+
+bubbleSort([1, 4, 2, 8, 345, 123, 43, 32, 5643, 63, 123, 43, 2, 55, 1, 234, 92]);

DS & Algo/implement-insertion-sort.js

@@ -0,0 +1,23 @@
+/*
+Algorithms: Implement Insertion Sort
+ This method works by building up a sorted array at the beginning of the list. 
+It begins the sorted array with the first element. Then it inspects the next element and 
+swaps it backwards into the sorted array until it is in sorted position.
+*/
+function insertionSort(arr) {
+  
+  for(let i=1; i<arr.length; i++){
+    let key = arr[i];
+    let j = i-1;
+    while(j>=0 && arr[j]>key){
+      arr[j+1] = arr[j];
+      j = j-1;
+    }
+    arr[j+1] = key;
+  }
+  console.log(arr);
+  return arr;
+
+}
+
+insertionSort([1, 4, 2, 8, 345, 123, 43, 32, 5643, 63, 123, 43, 2, 55, 1, 234, 92]);

DS & Algo/implement-quick-sort.js

@@ -0,0 +1,79 @@
+/*
+Algorithms: Implement Quick Sort
+
+The key process in quickSort is partition().
+ Target of partitions is, given an array and an element x of array as pivot, 
+put x at its correct position in sorted array and put all smaller elements (smaller than x) before x, 
+and put all greater elements (greater than x) after x.
+All this should be done in linear time.
+*/
+function partition(arr, left, right){
+  let pivot = arr[right];
+  let shift = left-1;
+  for(let j=left; j<right; j++){
+    if(arr[j]<pivot){
+      shift++;
+      [arr[shift], arr[j]] = [arr[j], arr[shift]];
+    }
+  }
+  [arr[shift+1], arr[right]] = [arr[right], arr[shift+1]];
+  return shift+1;
+}
+
+function quickSort(arr, left=0, right=arr.length-1) {
+  
+  if(left<right){
+    /* pi is partitioning index, arr[p] is now  
+        at right place */
+    let pi = partition(arr, left, right);
+    quickSort(arr, left, pi-1);
+    quickSort(arr, pi+1, right);
+  }
+  return arr;
+}
+
+// test array:
+const array = quickSort([1, 4, 2, 8, 345, 123, 43, 32, 5643, 63, 123, 43, 2, 55, 1, 234, 92]);
+
+console.log(array);
+/*
+Illustration of partition() :
+
+arr[] = {10, 80, 30, 90, 40, 50, 70}
+Indexes:  0   1   2   3   4   5   6 
+
+low = 0, high =  6, pivot = arr[h] = 70
+Initialize index of smaller element, i = -1
+
+Traverse elements from j = low to high-1
+j = 0 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])
+i = 0 
+arr[] = {10, 80, 30, 90, 40, 50, 70} // No change as i and j 
+                                     // are same
+
+j = 1 : Since arr[j] > pivot, do nothing
+// No change in i and arr[]
+
+j = 2 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])
+i = 1
+arr[] = {10, 30, 80, 90, 40, 50, 70} // We swap 80 and 30 
+
+j = 3 : Since arr[j] > pivot, do nothing
+// No change in i and arr[]
+
+j = 4 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])
+i = 2
+arr[] = {10, 30, 40, 90, 80, 50, 70} // 80 and 40 Swapped
+j = 5 : Since arr[j] <= pivot, do i++ and swap arr[i] with arr[j] 
+i = 3 
+arr[] = {10, 30, 40, 50, 80, 90, 70} // 90 and 50 Swapped 
+
+We come out of loop because j is now equal to high-1.
+Finally we place pivot at correct position by swapping
+arr[i+1] and arr[high] (or pivot) 
+arr[] = {10, 30, 40, 50, 70, 90, 80} // 80 and 70 Swapped 
+
+Now 70 is at its correct place. All elements smaller than
+70 are before it and all elements greater than 70 are after
+it.
+*/

DS & Algo/implement-selection-sort.js

@@ -0,0 +1,17 @@
+/* Algorithms: Implement Selection Sort */
+function selectionSort(arr) {
+  // change code below this line
+  for(let i=0; i<arr.length; i++){
+    let Min = i;
+    for(let j=i+1; j<arr.length; j++){
+        if(arr[Min]>arr[j]) Min = j;
+    }
+    [arr[i], arr[Min]] = [arr[Min], arr[i]];
+  }
+  console.log(arr);
+  return arr;
+  // change code above this line
+}
+
+
+selectionSort([1, 4, 2, 8, 345, 123, 43, 32, 5643, 63, 123, 43, 2, 55, 1, 234, 92]);

DS & Algo/inventory-update.js

@@ -0,0 +1,63 @@
+/*
+Algorithms: Inventory Update
+Compare and update the inventory stored in a 2D array against a second 2D array of a fresh delivery. 
+Update the current existing inventory item quantities (in arr1). 
+If an item cannot be found, add the new item and quantity into the inventory array. 
+The returned inventory array should be in alphabetical order by item.
+*/
+
+function updateInventory(arr1, arr2) {
+    // All inventory must be accounted for or you're fired!
+    arr2.forEach(elem => {
+        let flag = false;
+        for(let i in arr1){
+            if(arr1[i][1]===elem[1]){
+                arr1[i][0] += elem[0];
+                flag = true;
+            }
+        }
+        if(flag==false){
+            arr1.push(elem);
+        }
+    });
+    arr1.sort((a,b)=> a[1].localeCompare(b[1]));
+    console.log(arr1);
+    return arr1;
+}
+
+// Example inventory lists
+var curInv = [
+    [21, "Bowling Ball"],
+    [2, "Dirty Sock"],
+    [1, "Hair Pin"],
+    [5, "Microphone"]
+];
+
+var newInv = [
+    [2, "Hair Pin"],
+    [3, "Half-Eaten Apple"],
+    [67, "Bowling Ball"],
+    [7, "Toothpaste"]
+];
+
+updateInventory(curInv, newInv);
+
+
+/*
+The function updateInventory should return an array.
+Passed
+updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]) 
+should return an array with a length of 6.
+Passed
+updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]) 
+should return [[88, "Bowling Ball"], [2, "Dirty Sock"], [3, "Hair Pin"], [3, "Half-Eaten Apple"], [5, "Microphone"], [7, "Toothpaste"]].
+Passed
+updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], []) 
+should return [[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]].
+Passed
+updateInventory([], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]) 
+should return [[67, "Bowling Ball"], [2, "Hair Pin"], [3, "Half-Eaten Apple"], [7, "Toothpaste"]].
+Passed
+updateInventory([[0, "Bowling Ball"], [0, "Dirty Sock"], [0, "Hair Pin"], [0, "Microphone"]], [[1, "Hair Pin"], [1, "Half-Eaten Apple"], [1, "Bowling Ball"], [1, "Toothpaste"]]) 
+should return [[1, "Bowling Ball"], [0, "Dirty Sock"], [1, "Hair Pin"], [1, "Half-Eaten Apple"], [0, "Microphone"], [1, "Toothpaste"]].
+*/

DS & Algo/no-repeats-please.js

@@ -0,0 +1,56 @@
+/*
+Algorithms: No Repeats Please
+Return the number of total permutations of the provided string that don't have repeated consecutive letters. Assume that all characters in the provided string are each unique.
+
+For example, aab should return 2 because it has 6 total permutations (aab, aab, aba, aba, baa, baa), but only 2 of them (aba and aba) don't have the same letter (in this case a) repeating.
+*/
+
+function permAlone(str) {
+  let arr = str.split("");
+
+  let result = [];
+  function permute(arr, l, r){
+      if(l==r){
+        result.push(arr.join(""));
+      }
+      else{
+        for(let i=l; i<=r; i++){
+            [arr[i], arr[l]] = [arr[l], arr[i]]; //swap position
+            permute(arr, l+1, r); //recursive call
+
+            [arr[i], arr[l]] = [arr[l], arr[i]]; //swap back
+        }
+      }
+  };
+  permute(arr, 0, arr.length-1);
+  
+  let regex = /(.)\1+/; //matches the same text as most recently matched by the 1st capturing group
+
+  result = result.filter(item => !regex.test(item));
+ 
+  return result.length;
+}
+
+permAlone('a');
+
+/*
+permAlone("aab") should return a number.
+Passed
+permAlone("aab") should return 2.
+Passed
+permAlone("aaa") should return 0.
+Passed
+permAlone("aabb") should return 8.
+Passed
+permAlone("abcdefa") should return 3600.
+Passed
+permAlone("abfdefa") should return 2640.
+Passed
+permAlone("zzzzzzzz") should return 0.
+Passed
+permAlone("a") should return 1.
+Passed
+permAlone("aaab") should return 0.
+Passed
+permAlone("aaabb") should return 12.
+*/