2 more ejs

Author: megarbon

30 days JS/14-SleepPromises.js

@@ -0,0 +1,33 @@
+/*
+Given a positive integer millis, write an asynchronous function that sleeps for millis milliseconds. It can resolve any value.
+
+ 
+
+Example 1:
+
+Input: millis = 100
+Output: 100
+Explanation: It should return a promise that resolves after 100ms.
+let t = Date.now();
+sleep(100).then(() => {
+  console.log(Date.now() - t); // 100
+});
+Example 2:
+
+Input: millis = 200
+Output: 200
+Explanation: It should return a promise that resolves after 200ms.
+ 
+
+Constraints:
+
+1 <= millis <= 1000
+*/
+
+/**
+ * @param {number} millis
+ * @return {Promise}
+ */
+function sleep(millis) {
+	return new Promise((resolve) => setTimeout(resolve, millis));
+}

30 days JS/15-TimeOurCancelation.js

@@ -0,0 +1,82 @@
+/*
+Given a function fn, an array of arguments args, and a timeout t in milliseconds, return a cancel function cancelFn.
+
+After a delay of t, fn should be called with args passed as parameters unless cancelFn was invoked before the delay of t milliseconds elapses, specifically at cancelT ms. In that case, fn should never be called.
+
+ 
+
+Example 1:
+
+Input: fn = (x) => x * 5, args = [2], t = 20, cancelT = 50
+Output: [{"time": 20, "returned": 10}]
+Explanation: 
+const result = []
+
+const fn = (x) => x * 5
+
+const start = performance.now() 
+
+const log = (...argsArr) => {
+    const diff = Math.floor(performance.now() - start);
+    result.push({"time": diff, "returned": fn(...argsArr)})
+}
+     
+const cancel = cancellable(log, [2], 20);
+
+const maxT = Math.max(t, 50)
+          
+setTimeout(cancel, cancelT)
+
+setTimeout(() => {
+     console.log(result) // [{"time":20,"returned":10}]
+}, 65)
+
+The cancellation was scheduled to occur after a delay of cancelT (50ms), which happened after the execution of fn(2) at 20ms.
+Example 2:
+
+Input: fn = (x) => x**2, args = [2], t = 100, cancelT = 50 
+Output: []
+Explanation: The cancellation was scheduled to occur after a delay of cancelT (50ms), which happened before the execution of fn(2) at 100ms, resulting in fn(2) never being called.
+Example 3:
+
+Input: fn = (x1, x2) => x1 * x2, args = [2,4], t = 30, cancelT = 100
+Output: [{"time": 30, "returned": 8}]
+Explanation: The cancellation was scheduled to occur after a delay of cancelT (100ms), which happened after the execution of fn(2,4) at 30ms.
+ 
+
+Constraints:
+
+fn is a function
+args is a valid JSON array
+1 <= args.length <= 10
+20 <= t <= 1000
+10 <= cancelT <= 1000
+*/
+
+/**
+ * @param {Function} fn
+ * @param {Array} args
+ * @param {number} t
+ * @return {Function}
+ */
+const args = [2],
+	t = 20,
+	cancelT = 50;
+const fn = (x) => x * 5;
+const result = [];
+
+// Create a cancellable timeout
+var cancellable = function (fn, args, t) {
+	// Define a cancel function that will clear the timeout
+	const cancelFn = () => clearTimeout(idTimeout);
+
+	// Set up a timeout to execute the function after the specified delay
+	const idTimeout = setTimeout(() => fn(...args), t);
+
+	// When/if we call the function, it will return cancelFn,
+	// and since the return line calls (and consequentially executes)
+	// cancelFn, timeout will be cancelled, thereby cancelling fn execution.
+	return cancelFn;
+};
+
+console.log(cancellable(fn, args, t));

Challenges JS/logic/test.html

@@ -4,21 +4,22 @@
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<title>Document</title>
 		<script>
-			var compose = function (functions) {
-				return function (x) {
-					return functions.reduceRight((accumulator, currentFunction) => {
-						return currentFunction(accumulator);
-					}, x);
-				};
-			};
+			const args = [2],
+				t = 60,
+				cancelT = 50;
+			const fn = (x) => x * 5;
+			const result = [];
 
-			const funcs1 = [(x) => x + 1, (x) => x * x, (x) => 2 * x];
-			const funcs2 = [(x) => 10 * x, (x) => 10 * x, (x) => 10 * x];
-			const funcs3 = [];
+			var cancellable = function (fn, args, t) {
+				if (t < cancelT) {
+					return fn(...args);
+				} else {
+					//cancel the call of the function
+					return false;
+				}
+			};
 
-			console.log(compose(funcs1)(4));
-			console.log(compose(funcs2)(1));
-			console.log(compose(funcs3)(42));
+			console.log(cancellable(fn, args, t));
 		</script>
 	</head>
 	<body></body>