feat: Solved 4 Leetcode problems

ralvarezdev · ralvarezdev · commit a45c85897232 · 2024-06-25T11:12:58.000-04:00
* Solved 4 Leetcode problems from the 30 Days of JavaScript study plan
diff --git a/.idea/.gitignore b/.idea/.gitignore
diff --git a/30-days-of-javascript/promises-and-time/medium/cache-with-time-limit.js b/30-days-of-javascript/promises-and-time/medium/cache-with-time-limit.js
@@ -0,0 +1,66 @@
+var TimeLimitedCache = function () {
+
+};
+
+/**
+ * @param {number} key
+ * @param {number} value
+ * @param {number} duration time until expiration in ms
+ * @return {boolean} if un-expired key already existed
+ */
+TimeLimitedCache.prototype.set = function (key, value, duration) {
+    if (this.map === undefined) {
+        this.map = new Map();
+        this.accessible = new Map()
+    }
+
+    const exists = this.map.has(key)
+    this.map.set(key, value)
+    this.accessible.set(key, true)
+
+    setTimeout(() => {
+        if (this.map.get(key) === value)
+            this.accessible.set(key, false)
+    }, duration)
+
+    return exists
+};
+
+/**
+ * @param {number} key
+ * @return {number} value associated with key
+ */
+TimeLimitedCache.prototype.get = function (key) {
+    if (this.map === undefined)
+        return -1
+
+    const accessible = this.accessible.get(key)
+
+    if (!accessible)
+        return -1
+
+    return this.map.get(key)
+}
+
+/**
+ * @return {number} count of non-expired keys
+ */
+TimeLimitedCache.prototype.count = function () {
+    let count = 0
+
+    if (this.map === undefined)
+        return count
+
+    for (const accessible of this.accessible.values())
+        if (accessible)
+            count++
+
+    return count
+}
+
+/**
+ * const timeLimitedCache = new TimeLimitedCache()
+ * timeLimitedCache.set(1, 42, 1000); // false
+ * timeLimitedCache.get(1) // 42
+ * timeLimitedCache.count() // 1
+ */
diff --git a/30-days-of-javascript/promises-and-time/medium/debounce.js b/30-days-of-javascript/promises-and-time/medium/debounce.js
@@ -0,0 +1,27 @@
+/**
+ * @param {Function} fn
+ * @param {number} t milliseconds
+ * @return {Function}
+ */
+var debounce = function (fn, t) {
+    let called = false
+    let timer
+
+    return function (...args) {
+        if (called)
+            clearTimeout(timer)
+
+        timer = setTimeout(() => {
+            fn(...args)
+            called = false
+        }, t)
+        called = true
+    }
+};
+
+/**
+ * const log = debounce(console.log, 100);
+ * log('Hello'); // cancelled
+ * log('Hello'); // cancelled
+ * log('Hello'); // Logged at t=100ms
+ */
diff --git a/30-days-of-javascript/promises-and-time/medium/execute-asynchronous-functions-in-parallel-solution1.js b/30-days-of-javascript/promises-and-time/medium/execute-asynchronous-functions-in-parallel-solution1.js
@@ -0,0 +1,24 @@
+/**
+ * @param {Array<Function>} functions
+ * @return {Promise<any>}
+ */
+var promiseAll = function(functions) {
+    return new Promise((resolve, reject)=>
+        {
+            (async ()=>{
+                functions.forEach((func, i)=>{
+                    functions[i]=func().catch(err=>reject(err))
+                })
+
+                for(let i=0;i<functions.length;i++)
+                    functions[i] = await functions[i];
+
+                resolve(functions)
+            })()
+        })
+}
+
+/**
+ * const promise = promiseAll([() => new Promise(res => res(42))])
+ * promise.then(console.log); // [42]
+ */
diff --git a/30-days-of-javascript/promises-and-time/medium/execute-asynchronous-functions-in-parallel-solution2.js b/30-days-of-javascript/promises-and-time/medium/execute-asynchronous-functions-in-parallel-solution2.js
@@ -0,0 +1,26 @@
+/**
+ * @param {Array<Function>} functions
+ * @return {Promise<any>}
+ */
+var promiseAll = function(functions) {
+    return new Promise((resolve, reject)=>
+        {
+            let counter=0;
+
+            functions.forEach((func, i)=>{
+                    func()
+                    .then(result=>{
+                        functions[i]=result
+
+                        if(++counter===functions.length)
+                            resolve(functions)
+                    })
+                    .catch(err=>reject(err))
+                })
+        })
+}
+
+/**
+ * const promise = promiseAll([() => new Promise(res => res(42))])
+ * promise.then(console.log); // [42]
+ */
diff --git a/30-days-of-javascript/promises-and-time/medium/promise-time-limit.js b/30-days-of-javascript/promises-and-time/medium/promise-time-limit.js
@@ -0,0 +1,18 @@
+/**
+ * @param {Function} fn
+ * @param {number} t
+ * @return {Function}
+ */
+var timeLimit = function(fn, t) {
+    return async function(...args) {
+        return new Promise((resolve, reject)=>{
+            fn(...args).then(resolve).catch(reject)
+            setTimeout(()=>reject("Time Limit Exceeded"),t)
+        })
+    }
+};
+
+/**
+ * const limited = timeLimit((t) => new Promise(res => setTimeout(res, t)), 100);
+ * limited(150).catch(console.log) // "Time Limit Exceeded" at t=100ms
+ */
