finnaly hard question

Author: someoneudonknow

Eazy/13_RomantoInteger.js

@@ -0,0 +1,39 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var romanToInt = function (s) {
+  const symbols = {
+    I: 1,
+    V: 5,
+    X: 10,
+    L: 50,
+    C: 100,
+    D: 500,
+    M: 1000,
+  };
+
+  let left = 0,
+    right = left + 1;
+  const n = s.length;
+  let sum = 0;
+
+  while (left < n) {
+    if (
+      (s[left] === "I" && (s[right] === "V" || s[right] === "X")) ||
+      (s[left] === "X" && (s[right] === "L" || s[right] === "C")) ||
+      (s[left] === "C" && (s[right] === "D" || s[right] === "M"))
+    ) {
+      const re = symbols[s[right]] - symbols[s[left]];
+      sum += re;
+      right += 2;
+      left += 2;
+    } else {
+      sum += symbols[s[left]];
+      left++;
+      right++;
+    }
+  }
+
+  return sum;
+};

Eazy/1544_MakeTheStringGreat.js

@@ -0,0 +1,36 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var makeGood = function (s) {
+  const n = s.length;
+
+  if (n === 1) return s[0];
+
+  let rs = s.split("");
+  let isValid = false;
+
+  while (!isValid) {
+    let cnt = 0;
+    if (rs.length === 1) {
+      isValid = true;
+    }
+
+    for (let i = 0; i < rs.length - 1; i++) {
+      if (Math.abs(rs[i].charCodeAt(0) - rs[i + 1].charCodeAt(0)) === 32) {
+        rs.splice(i, 2);
+        isValid = false;
+        cnt++;
+        break;
+      }
+    }
+
+    if (cnt === 0) {
+      isValid = true;
+    }
+  }
+
+  return rs.join("");
+};
+
+export default makeGood;

Eazy/2629_FunctionComposition.js

@@ -0,0 +1,28 @@
+/**
+ * @param {Function[]} functions
+ * @return {Function}
+ */
+var compose = function (functions) {
+    let currentData;
+    return function (x) {
+        if (functions.length <= 0) return x;
+        
+        for (let i = functions.length - 1; i >= 0; i--) {
+            if (!currentData) {
+                currentData = functions[i](x);
+            } else {
+                currentData = functions[i](currentData)
+            }
+        }
+
+        return currentData
+    }
+};
+
+//OR with reduce right methods and one line of code
+var compose = functions => functions.length === 0 ? x => x : functions.reduceRight((prev, curr) => x => curr(prev(x)));
+
+/**
+ * const fn = compose([x => x + 1, x => 2 * x])
+ * fn(4) // 9
+ */

Eazy/2665_CounterII.js

@@ -0,0 +1,21 @@
+/**
+ * @param {integer} init
+ * @return { increment: Function, decrement: Function, reset: Function }
+ */
+var createCounter = function (init) {
+    let val = init;
+    return {
+        increment: () => ++val,
+        decrement: () => --val,
+        reset: () => val = init
+    }
+};
+
+/**
+ * const counter = createCounter(5)
+ * counter.increment(); // 6
+ * counter.reset(); // 5
+ * counter.decrement(); // 4
+ */
+
+export default createCounter;

Eazy/2666_AllowOneFunctionCall.js

@@ -0,0 +1,22 @@
+/**
+ * @param {Function} fn
+ * @return {Function}
+ */
+var once = function(fn) {
+    let cnt = 0;
+    return function(...args){
+        if(cnt === 0) {
+            cnt = 1;
+            return fn(...args);
+        }
+        return undefined
+    }
+};
+
+/**
+ * let fn = (a,b,c) => (a + b + c)
+ * let onceFn = once(fn)
+ *
+ * onceFn(1,2,3); // 6
+ * onceFn(2,3,6); // returns undefined without calling fn
+ */

Eazy/27_RemoveElement.js

@@ -0,0 +1,47 @@
+/**
+ * @param {number[]} nums
+ * @param {number} val
+ * @return {number}
+ */
+var removeElement = function (nums, val) {
+  let lo = 0,
+    hi = nums.length - 1;
+
+  let k = 0;
+
+  while (lo < hi) {
+    if (nums[lo] === val && nums[hi] !== val) {
+      const tmp = nums[lo];
+      nums[lo] = nums[hi];
+      nums[hi] = tmp;
+      lo++;
+    } else if (nums[lo] === val && nums[hi] === val) {
+      hi--;
+    } else {
+      lo++;
+    }
+  }
+
+  for (let e of nums) {
+    if (e !== val) {
+      k++;
+    }
+  }
+
+  return k;
+};
+// another solution without two pointers
+function removeElement(nums, val) {
+  // Counter for keeping track of elements other than val
+  let count = 0;
+  // Loop through all the elements of the array
+  for (let i = 0; i < nums.length; i++) {
+    // If the element is not val
+    if (nums[i] !== val) {
+      nums[count++] = nums[i];
+    }
+  }
+  return count;
+}
+
+export default removeElement;

Hard/273_IntegertoEnglishWords.js

@@ -0,0 +1,70 @@
+/**
+ * @param {number} num
+ * @return {string}
+ */
+var numberToWords = function (num) {
+  if (num === 0) return "Zero";
+
+  const LOWER_THAN_20 = [
+    "",
+    "One",
+    "Two",
+    "Three",
+    "Four",
+    "Five",
+    "Six",
+    "Seven",
+    "Eight",
+    "Nine",
+    "Ten",
+    "Eleven",
+    "Twelve",
+    "Thirteen",
+    "Fourteen",
+    "Fifteen",
+    "Sixteen",
+    "Seventeen",
+    "Eighteen",
+    "Nineteen",
+  ];
+  const LOWER_THAN_100 = [
+    "",
+    "Ten",
+    "Twenty",
+    "Thirty",
+    "Forty",
+    "Fifty",
+    "Sixty",
+    "Seventy",
+    "Eighty",
+    "Ninety",
+  ];
+
+  const helper = (num) => {
+    if (num >= 1000000000) {
+      return (
+        helper(parseInt(num / 1000000000)) +
+        " Billion" +
+        helper(num % 1000000000)
+      );
+    } else if (num >= 1000000) {
+      return (
+        helper(parseInt(num / 1000000)) + " Million" + helper(num % 1000000)
+      );
+    } else if (num >= 1000) {
+      return helper(parseInt(num / 1000)) + " Thousand" + helper(num % 1000);
+    } else if (num >= 100) {
+      return helper(parseInt(num / 100)) + " Hundred" + helper(num % 100);
+    } else if (num >= 20) {
+      return " " + LOWER_THAN_100[parseInt(num / 10)] + helper(num % 10);
+    } else if (num > 0) {
+      return " " + LOWER_THAN_20[parseInt(num)];
+    } else {
+      return "";
+    }
+  };
+
+  return helper(num).trim();
+};
+
+export default numberToWords;

Medium/12_IntegertoRoman.js

@@ -0,0 +1,49 @@
+/**
+ * @param {number} num
+ * @return {string}
+ */
+var intToRoman = function (num) {
+  const symbols = {
+    1: "I",
+    5: "V",
+    10: "X",
+    50: "L",
+    100: "C",
+    500: "D",
+    1000: "M",
+    4: "IV",
+    9: "IX",
+    40: "XL",
+    90: "XC",
+    400: "CD",
+    900: "CM",
+  };
+
+  let roman = "";
+  let cal = num;
+
+  while (cal > 0) {
+    const div = cal - (cal % 10 ** ((Math.log(cal) * Math.LOG10E + 1 | 0) - 1));
+    if (!symbols[div]) {
+      let cnt = div;
+      let leftOver = div;
+      while (leftOver > 0) {
+        if (symbols[cnt]) {
+          roman += symbols[cnt];
+          leftOver -= cnt;
+          cnt = leftOver;
+        } else {
+          cnt--;
+        }
+      }
+    } else {
+      roman += symbols[div];
+    }
+
+    cal = cal % 10 ** ((Math.log(cal) * Math.LOG10E + 1 | 0) - 1);
+  }
+
+  return roman;
+};
+
+export default intToRoman;

Medium/3_LongestSubstringWithoutRepeatingCharacters.js

@@ -0,0 +1,36 @@
+// my stupid solution
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function (s) {
+  let left = 0,
+    right = 0;
+  let longestLength = 0;
+  const n = s.length;
+  let lettersMap = new Map();
+
+  while (right <= n) {
+    if (isNaN(lettersMap.get(s[right]))) {
+      lettersMap.set(s[right], 1);
+    } else {
+      if (right - left > longestLength) {
+        longestLength = right - left;
+      }
+      let newMap = Array.from(lettersMap);
+      newMap.splice(0, right + 1);
+      lettersMap = new Map(newMap);
+      left = left + 1;
+      right = left;
+      lettersMap.set(s[left], 1);
+    }
+    if (right === n) {
+      if (right - left > longestLength) {
+        longestLength = right - left;
+      }
+    }
+    right++;
+  }
+
+  return longestLength;
+};