prettier

Author: zachblume

.prettierrc

@@ -0,0 +1 @@
+{}

13romanToInteger.js

@@ -0,0 +1,51 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+let hash = {
+  I: 1,
+  V: 5,
+  X: 10,
+  L: 50,
+  C: 100,
+  D: 500,
+  M: 1000,
+};
+var romanToInt = function (s) {
+  let number = 0;
+  for (let i = s.length - 1; i > -1; i--) {
+    let char = s[i];
+    let prev = s[i - 1];
+    let two = prev + char;
+    switch (two) {
+      case "IV":
+        number += 4;
+        i--;
+        break;
+      case "IX":
+        number += 9;
+        i--;
+        break;
+      case "XL":
+        number += 40;
+        i--;
+        break;
+      case "XC":
+        number += 90;
+        i--;
+        break;
+      case "CD":
+        number += 400;
+        i--;
+        break;
+      case "CM":
+        number += 900;
+        i--;
+        break;
+      default:
+        number += hash[char];
+        break;
+    }
+  }
+  return number;
+};

1480runningSumOf1dArray.js

@@ -5,9 +5,9 @@
  * @param {number[]} nums
  * @return {number[]}
  */
-var runningSum = function(nums) {
-    for (let i=0;i<nums.length;i++) {
-        nums[i] = nums[i] + (nums[i-1]||0)
-    }
-    return nums;
-};
+var runningSum = function (nums) {
+  for (let i = 0; i < nums.length; i++) {
+    nums[i] = nums[i] + (nums[i - 1] || 0);
+  }
+  return nums;
+};

205isomorphicString.js

@@ -4,17 +4,23 @@
  * Two strings s and t are isomorphic if the characters in s can be replaced to get t.
  * All occurrences of a character must be replaced with another character while preserving
  * the order of characters. No two characters may map to the same character, but a
-* character may map to itself.
+ * character may map to itself.
  * @param {string} s - renamed to a
  * @param {string} t - renamed to b
  * @return {boolean}
  */
 var isIsomorphic = function (a, b) {
   if (a.length !== b.length) return false;
 
-  let aX = "", bX = "", hashForA = [], hashForB = [], aCounter = 0, bCounter = 0;
+  let aX = "",
+    bX = "",
+    hashForA = [],
+    hashForB = [],
+    aCounter = 0,
+    bCounter = 0;
   for (let i = 0; i < a.length; i++) {
-    let charA = a[i], charB = b[i];
+    let charA = a[i],
+      charB = b[i];
 
     if (hashForA[charA] == undefined) {
       hashForA[charA] = aCounter;
@@ -36,16 +42,18 @@ var isIsomorphic = function (a, b) {
 var isIsomorphic = (a, b) => {
   if (a.length !== b.length) return false;
 
-  let a2b = [], b2a = [];
+  let a2b = [],
+    b2a = [];
   for (let i = 0; i < a.length; i++) {
-    let aChar = a[i], bChar = b[i];
-    if(
-        (a2b[aChar] || b2a[bChar])
-        &&
-        (a2b[aChar] !== bChar || b2a[bChar] !== aChar)
-    ) return false;
-    if (!a2b[aChar]) a2b[aChar]=bChar;
-    if (!b2a[bChar]) b2a[bChar]=aChar;
+    let aChar = a[i],
+      bChar = b[i];
+    if (
+      (a2b[aChar] || b2a[bChar]) &&
+      (a2b[aChar] !== bChar || b2a[bChar] !== aChar)
+    )
+      return false;
+    if (!a2b[aChar]) a2b[aChar] = bChar;
+    if (!b2a[bChar]) b2a[bChar] = aChar;
   }
   return true;
-};
+};

21mergeTwoSortedLists.js

@@ -16,11 +16,15 @@
  * @return {ListNode}
  */
 var mergeTwoLists = function (a, b) {
-  if (!a ?? !b) return a ? a : b
+  if (!a ?? !b) return a ? a : b;
   // Make left less than or equal to right
-  let left = null, right = null;
-  if (a.val <= b.val) { left = a, right = b; }
-  else { left = b, right = a; }
+  let left = null,
+    right = null;
+  if (a.val <= b.val) {
+    (left = a), (right = b);
+  } else {
+    (left = b), (right = a);
+  }
 
   // Store head for end
   let head = left;
@@ -29,7 +33,7 @@ var mergeTwoLists = function (a, b) {
   while (left && right) {
     if (left?.next?.val <= right?.val) {
       // Move forward
-      left = left.next
+      left = left.next;
     } else {
       // Unshift right node into left list
       left.next = new ListNode(right.val, left.next);
@@ -40,4 +44,4 @@ var mergeTwoLists = function (a, b) {
 
   // Return new head node of merged lists,
   return head;
-};
+};

22generateParentheses.js

@@ -5,6 +5,23 @@
  * @param {number} n
  * @return {string[]}
  */
-var generateParenthesis = function(n) {
-    
-};
+var generateParenthesis = function (n) {
+  // Edge cases
+  if (n < 1) return [];
+  if (n == 1) return ["()"];
+
+  let solutions = [];
+
+  // Closures
+  let nextLevel = generateParenthesis(n - 1);
+  solutions.push(...nextLevel.map((a) => "(" + a + ")"));
+  solutions.push(...nextLevel.map((a) => "()" + a));
+  nextLevel.forEach((a) => {
+    if (!isBalanced(a)) solutions.push(a + "()");
+  });
+
+  return solutions;
+};
+function isBalanced(s) {
+  return s.replaceAll("()", "") == "";
+}

392isSubsequence.js

@@ -11,7 +11,7 @@
 var isSubsequence = function (s, t) {
   let cursor = 0;
   for (let i = 0; i < t.length; i++) {
-    if (t[i] == s[cursor]) cursor++
+    if (t[i] == s[cursor]) cursor++;
   }
   return cursor == s.length;
-};
+};

724findPivotIndex.js

@@ -10,15 +10,16 @@
  * @return {number}
  */
 var pivotIndex = (nums) => {
-  let prefixSum = [], postfixSum = [];
+  let prefixSum = [],
+    postfixSum = [];
   for (let i = 0; i < nums.length; i++) {
     let j = nums.length - 1 - i;
-    postfixSum[j] = (postfixSum[j + 1] || 0) + nums[j]
-    prefixSum[i] = (prefixSum[i - 1] || 0) + nums[i]
+    postfixSum[j] = (postfixSum[j + 1] || 0) + nums[j];
+    prefixSum[i] = (prefixSum[i - 1] || 0) + nums[i];
   }
   for (let i = 0; i < nums.length; i++) {
     let j = nums.length - 1 - i;
     if ((prefixSum[i - 1] || 0) == (postfixSum[i + 1] || 0)) return i;
   }
   return -1;
-};
+};

README.md

@@ -1,4 +1,5 @@
 # algorithms-and-data-structures
+
 Studying data structures & algorithms
 
 [1480. Running Sum of 1d Array](1480runningSumOf1dArray.js)
@@ -9,4 +10,4 @@ Studying data structures & algorithms
 
 [392. Is Subsequence](392isSubsequence.js)
 
-[21. Merge Two Sorted Lists](21mergeTwoSortedLists.js)
+[21. Merge Two Sorted Lists](21mergeTwoSortedLists.js)

crackingTheCodingInterviewBookProblems.js

@@ -0,0 +1,50 @@
+/* Page 70
+ * 'There is an O(N) algorithm.'
+ * Given a smaller string s and a bigger string b, design an
+ * algorithm to find all permutations of the shorter string
+ * within the longer one. Print the location each permutation.
+ */
+const findPermutations = (needle, haystack) => {
+  // Store a array of location solutions
+  let locations = [];
+
+  // This is a named constraint that helps us get to O(haystack)
+  // instead of O(needle) because: needle < haystack = true
+  if (needle.length > haystack.length) console.error("But the book promised!!");
+
+  // Let countmap
+  let needleHash = [];
+
+  // Loop through the haystack and make a hash
+  for (let i = 0; i < needle.length; i++) {
+    // Get the current character at this haystack position
+    let char = neelde[i];
+
+    //
+    if (!needleHash[char]) needleHash[char] = [];
+    needleHash[char][i] = true;
+  }
+
+  // Loop through again for cursor/counter magic
+  for (let i = 0; i < haystack.length; i++) {
+    // Get the current character at this haystack position
+    let char = haystack[i];
+
+    // If this character is present in the needle...
+    if (hash[char]) {
+      // Start a cursor at this positions
+      cursor[i];
+    }
+  }
+
+  // locations = haystackCounterHash.filter()
+  console.log({ hash });
+
+  return locations;
+};
+
+// Example from book
+let needle = "abbc";
+let haystack = "cbabadcbbabbcbabaabccbabc";
+let result = findPermutations(needle, haystack);
+console.log(result);