update

Author: MaiDeveloper

combination.js

@@ -0,0 +1,25 @@
+function combinations (m, n) {
+  const nums = [0, 1, 2, 3, 4];
+  const result = [];
+
+  backtracking(nums, '', 0, 4);
+
+  function backtracking(nums, str, start, len) {
+    if (str.length === 3) {
+      const t = str.split('').sort().join('');
+      if (result.indexOf(t) === -1) {
+        result.push(t);
+      }
+    }
+
+    for (let i = start; i <= len; i++) {
+      backtracking(nums, str + nums[i], start + 1, len);
+    }
+
+  }
+
+
+  return result;
+}
+
+console.log(combinations(3, 5));

insertion-sort.js

@@ -0,0 +1,24 @@
+/**
+ * Algorithms: Implement Insertion Sort
+ * The next sorting method we'll look at is 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. It continues iterating through the list and swapping new items backwards into the sorted portion until it reaches the end. This algorithm has quadratic time complexity in the average and worst cases.
+ *
+ * Instructions: Write a function insertionSort which takes an array of integers as input and returns an array of these integers in sorted order from least to greatest.
+ */
+
+function insertionSort(array) {
+  for (let i = 1, l = array.length; i < l; i++) {
+    const val = array[i];
+    let j = i - 1;
+
+    while (j >= 0 && array[j] > val) {
+      array[j + 1] = array[j];
+      j--;
+    }
+
+    array[j + 1] = val;
+  }
+  return array;
+}
+
+
+console.log(insertionSort([1, 4, 2, 8, 345, 123, 43, 32, 5643, 63, 123, 43, 2, 55, 1, 234, 92]));

matching-parenthesis-position.js

@@ -0,0 +1,34 @@
+/**
+ * I like parentheticals (a lot).
+ *
+ * "Sometimes (when I nest them (my parentheticals) too much (like this (and this))) they get confusing."
+ *
+ * Write a function that, given a sentence like the one above, along with the position of an opening parenthesis, finds the corresponding closing parenthesis.
+ *
+ * Example: if the example string above is input with the number 10 (position of the first parenthesis), the output should be 79 (position of the last parenthesis).
+ */
+
+function getClosingParen(sentence, openingIndex) {
+  let balance = 0;
+
+  for (let i = openingIndex, l = sentence.length; i < l; i++) {
+    let char = sentence.charAt(i);
+
+    if (char === '(') {
+      balance++;
+    } else if (char === ')') {
+      balance--;
+    }
+
+    if (balance === 0) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+let str = 'Sometimes (when I nest them (my parentheticals) too much (like this (and this))) they get confusing.';
+
+console.log(getClosingParen(str, 10));
+

pair-wise.js

@@ -0,0 +1,43 @@
+const assert = require('assert');
+/**
+ * Algorithms: Pairwise
+ * Given an array arr, find element pairs whose sum equal the second argument arg and return the sum of their indices.
+ *
+ * You may use multiple pairs that have the same numeric elements but different indices. Each pair should use the lowest possible available indices. Once an element has been used it cannot be reused to pair with another element. For instance, pairwise([1, 1, 2], 3) creates a pair [2, 1] using the 1 at indice 0 rather than the 1 at indice 1, because 0+2 < 1+2.
+ *
+ * For example pairwise([7, 9, 11, 13, 15], 20) returns 6. The pairs that sum to 20 are [7, 13] and [9, 11]. We can then write out the array with their indices and values.
+ * Index	0	1	2	3	4
+ * Value	7	9	11	13	15
+ *
+ * Below we'll take their corresponding indices and add them.
+ *
+ * 7 + 13 = 20 → Indices 0 + 3 = 3
+ * 9 + 11 = 20 → Indices 1 + 2 = 3
+ * 3 + 3 = 6 → Return 6
+ */
+
+function pairwise(arr, target) {
+  let ans = 0;
+  const nums = {};
+
+  for (let i = 0, l = arr.length; i < l; i++) {
+    const val = target - arr[i];
+
+    if (nums[val] !== undefined && nums[val].length > 0) {
+      ans += nums[val].shift() + i;
+    } else {
+      nums[arr[i]] = nums[arr[i]] || [];
+      nums[arr[i]].push(i);
+    }
+  }
+  return ans;
+}
+
+
+assert.deepStrictEqual(pairwise([1,4,2,3,0,5], 7), 11);
+assert.deepStrictEqual(pairwise([1, 3, 2, 4], 4), 1);
+assert.deepStrictEqual(pairwise([1, 1, 1], 2), 1);
+assert.deepStrictEqual(pairwise([0, 0, 0, 0, 1, 1], 1), 10);
+assert.deepStrictEqual(pairwise([], 100), 0);
+
+

product-all-other-numbers-except-index.js

@@ -0,0 +1,49 @@
+/**
+ * You have a list of integers, and for each index you want to find the product of every integer except the integer at that index.
+ *
+ * Write a function get_products_of_all_ints_except_at_index() that takes a list of integers and returns a list of the products.
+ *
+ * For example, given:
+ *
+ * [1, 7, 3, 4]
+ *
+ * your function would return:
+ *
+ * [84, 12, 28, 21]
+ *
+ * by calculating:
+ *
+ * [7 * 3 * 4,  1 * 3 * 4,  1 * 7 * 4,  1 * 7 * 3]
+ *
+ * Here's the catch: You can't use division in your solution!
+ */
+
+function productAll(arr) {
+  if (arr.length < 2) {
+    throw Error('Required at least two numbers');
+  }
+
+  let ans = [];
+  let products = 1;
+
+  for (let i = 0, l = arr.length; i < l; i++) {
+    ans[i] = products;
+    products *= arr[i];
+  }
+
+  products = 1;
+
+  for (let i = ans.length - 1; i >= 0; i--) {
+    ans[i] *= products;
+    products *= arr[i];
+  }
+
+  return ans;
+}
+
+
+console.log(productAll([1, 7, 3, 4]));
+
+
+
+

recursive-string-permutations.js

@@ -0,0 +1,35 @@
+/**
+ * Permutation
+ *
+ * Write a recursive function for generating all permutations of an input string
+ */
+function permutation(str) {
+  const result = [];
+
+  backtracking(str.split(''), 0, str.length - 1, result);
+
+  return result;
+
+  function backtracking(str, start, end, result) {
+    if (start === end) {
+      result.push(str.join(''));
+      return;
+    }
+
+    for (let i = start; i <= end; i++) {
+      swap(str, i, start);
+      backtracking(str, start + 1, end, result);
+      swap(str, start, i);
+    }
+  }
+
+  function swap(arr, i, j) {
+    const t = arr[i];
+    arr[i] = arr[j];
+    arr[j] = t;
+  }
+}
+
+
+
+console.log(permutation('cat'));

selection-sort.js

@@ -0,0 +1,29 @@
+/**
+ * Algorithms: Implement Selection Sort
+ * Here we will implement selection sort. Selection sort works by selecting the minimum value in a list and swapping it with the first value in the list. It then starts at the second position, selects the smallest value in the remaining list, and swaps it with the second element. It continues iterating through the list and swapping elements until it reaches the end of the list. Now the list is sorted. Selection sort has quadratic time complexity in all cases.
+ *
+ * Instructions: Write a function selectionSort which takes an array of integers as input and returns an array of these integers in sorted order from least to greatest.
+ */
+
+function selectionSort(array) {
+  for (let i = 0, l = array.length; i < l - 1; i++) {
+    let low = i;
+    for (let j = i + 1; j < l; j++) {
+      if (array[j] < array[low]) {
+        low = j;
+      }
+    }
+
+    if (low !== i) {
+      const t = array[i];
+      array[i] = array[low];
+      array[low] = t;
+    }
+
+  }
+
+  return array;
+}
+
+
+console.log(selectionSort([1, 4, 2, 8, 345, 123, 43, 32, 5643, 63, 123, 43, 2, 55, 1, 234, 92]));