update

Author: someoneudonknow

Eazy/118_Pascal'sTriangle.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number} numRows
+ * @return {number[][]}
+ */
+var generate = function(numRows) {
+    let result = new Array(numRows).fill(null).map(_ => []);
+    
+    for(let i = 0;i < numRows;i++) {
+        result[i][0] = 1;
+        result[i][i] = 1;
+    }
+    
+    for(let i = 1;i < numRows;i++) {
+        for(let j = 1;j < i;j++) {
+            result[i][j] = result[i-1][j-1] + result[i-1][j];
+        }
+    }
+
+    return result;
+};
+
+export default generate;

Eazy/119_Pascal'sTriangleII.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number} rowIndex
+ * @return {number[]}
+ */
+var getRow = function (rowIndex) {
+    const result = new Array(rowIndex + 1).fill(null).map(_ => []);
+
+    for (let i = 0; i <= rowIndex; i++) {
+        result[i][0] = 1;
+        result[i][i] = 1;
+        for (let j = 1; j < i; j++) {
+            result[i][j] = result[i-1][j-1] + result[i-1][j];
+        }
+    }
+    
+    return result[rowIndex]
+};
+
+export default getRow;

Eazy/2637_PromiseTimeLimit.js

@@ -0,0 +1,28 @@
+/**
+ * @param {Function} fn
+ * @param {number} t
+ * @return {Function}
+ */
+var timeLimit = function (fn, t) {
+    return async function (...args) {
+        return new Promise(async (resolve, reject) => {
+            const timeOutId = setTimeout(() => {
+                reject("Time Limit Exceeded")
+            }, t);
+            try {
+                const rs = await fn(...args);
+                resolve(rs)
+            } catch (e) {
+                reject(e)
+            }
+            clearTimeout(timeOutId)
+        })
+    }
+};
+
+/**
+ * const limited = timeLimit((t) => new Promise(res => setTimeout(res, t)), 100);
+ * limited(150).catch(console.log) // "Time Limit Exceeded" at t=100ms
+ */
+
+export default timeLimit;

Eazy/2677_ChunkArray.js

@@ -0,0 +1,21 @@
+/**
+ * @param {Array} arr
+ * @param {number} size
+ * @return {Array[]}
+ */
+var chunk = function(arr, size) {
+    if(arr.length === 0) return [];
+    const re = [];
+    for(let i = 0;i < size;i++) {
+        if(arr[i] !== undefined) {
+            re.push(arr[i]);
+        }else {
+            break;
+        }
+    }
+    arr.splice(0,size);
+
+    return [re, ...chunk(arr,size)];
+};
+
+export default chunk;

Eazy/392_IsSubsequence.js

@@ -0,0 +1,24 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+
+// Dynamic programming
+var isSubsequence = function(s, t) {
+    const sameChars = new Array(s.length+1).fill(null).map(_ => new Array(t.length+1).fill(0));
+
+    for(let i = 1;i <= s.length;i++) {
+        for(let j = 1;j <= t.length;j++) {
+            if(t[j-1] === s[i-1]) {
+                sameChars[i][j] = sameChars[i-1][j-1] + 1;
+            }else {
+                sameChars[i][j] = Math.max(sameChars[i][j-1], sameChars[i-1][j]);
+            }
+        }
+    }
+    
+    return sameChars[s.length][t.length] === s.length ? true : false;
+};
+
+export default isSubsequence;

Medium/2622_CacheWithTimeLimit.js

@@ -0,0 +1,50 @@
+var TimeLimitedCache = function () {
+    this.cache = new Map();
+};
+
+/** 
+ * @param {number} key
+ * @param {number} value
+ * @param {number} time until expiration in ms
+ * @return {boolean} if un-expired key already existed
+ */
+TimeLimitedCache.prototype.set = function (key, value, duration) {
+    const valueInCache = this.cache.get(key);
+
+    if (valueInCache) {
+        clearTimeout(valueInCache.timeoutId)
+    };
+
+    const timeoutId = setTimeout(() => {
+        this.cache.delete(key);
+    }, duration)
+
+    this.cache.set(key, { value, timeoutId });
+
+    return !!valueInCache;
+};
+
+/** 
+ * @param {number} key
+ * @return {number} value associated with key
+ */
+TimeLimitedCache.prototype.get = function (key) {
+    return this.cache.get(key) ? this.cache.get(key).value : -1;
+};
+
+/** 
+ * @return {number} count of non-expired keys
+ */
+TimeLimitedCache.prototype.count = function () {
+    return this.cache.size;
+};
+
+/**
+ * Your TimeLimitedCache object will be instantiated and called as such:
+ * var obj = new TimeLimitedCache()
+ * obj.set(1, 42, 1000); // false
+ * obj.get(1) // 42
+ * obj.count() // 1
+ */
+
+export default TimeLimitedCache;

Medium/2628_JSONDeepEqual.js

@@ -0,0 +1,21 @@
+/**
+ * @param {any} o1
+ * @param {any} o2
+ * @return {boolean}
+ */
+var areDeeplyEqual = function (o1, o2) {
+    if (o1 === o2) return true;
+    if (String(o1) !== String(o2)) return false;
+    if (typeof o1 !== 'object') return o1 === o2;
+    if (Object.keys(o1).length !== Object.keys(o2).length) return false;
+
+    for (let key of Object.keys(o1)) {
+        if (!areDeeplyEqual(o1[key], o2[key])) {
+            return false;
+        }
+    }
+
+    return true;
+};
+
+export default areDeeplyEqual;

Medium/2632_Curry.js

@@ -0,0 +1,15 @@
+/**
+ * @param {Function} fn
+ * @return {Function}
+ */
+var curry = function (fn) {
+    return function curried(...args) {
+        if (args.length >= fn.length) {
+            return fn(...args);
+        }
+
+        return curried.bind(this, ...args);
+    };
+};
+
+export default curry;

Medium/2633_ConvertObjecttoJSONString.js

@@ -0,0 +1,19 @@
+/**
+ * @param {any} object
+ * @return {string}
+ */
+var jsonStringify = function(object) {
+    if(typeof object === 'string' || object instanceof String) return `"${object}"`;
+    
+    if(typeof object !== 'object' || object === null) return String(object);
+
+    if(Array.isArray(object)) {
+        const arrToString = object.map(curr => jsonStringify(curr));
+        return `[${arrToString.join()}]`;
+    }
+
+    let objToString = Object.keys(object).map(key => `"${key}":${jsonStringify(object[key])}`);
+    return `{${objToString.join()}}`
+};
+
+export default jsonStringify;

Medium/2636_PromisePool.js

@@ -0,0 +1,23 @@
+/**
+ * @param {Function[]} functions
+ * @param {number} n
+ * @return {Function}
+ */
+var promisePool = async function (functions, n) {
+  const evaluateNext = async () => {
+    if (functions.length === 0) return;
+    const currFn = functions.shift();
+    await currFn();
+    await evaluateNext();
+  };
+  const promiseArr = Array(n).fill().map(evaluateNext);
+  await Promise.all(promiseArr);
+};
+
+/**
+ * const sleep = (t) => new Promise(res => setTimeout(res, t));
+ * promisePool([() => sleep(500), () => sleep(400)], 1)
+ *   .then(console.log) // After 900ms
+ */
+
+export default promisePool;