add js challenge

Author: Barklim

example/README.md

@@ -270,6 +270,17 @@ Better order to solve problems
 1041. Robot Bounded In Circle
 1572. Matrix Diagonal Sum
 
+## 30 Days of JavaScript
+
+2667. Create Hello World Function
+2620. Counter
+2704. To Be Or Not To Be
+2665. Counter II
+2635. Apply Transform Over Each Element in Array
+2634. Filter Elements from Array
+2626. Array Reduce Transformation
+2629. Function Composition
+
 ### [Strong List](structy.net)
 
 1. Depth-First Search (DFS)

example/js/2620.js

@@ -0,0 +1,27 @@
+/**
+ * 2620. Counter
+ * https://leetcode.com/problems/counter/
+ * Difficulty: Easy
+ *
+ * Given an integer n, return a counter function. This counter function initially
+ * returns n and then returns 1 more than the previous value every subsequent
+ * time it is called (n, n + 1, n + 2, etc).
+ */
+
+/**
+ * @param {number} n
+ * @return {Function} counter
+ */
+var createCounter = function(n) {
+    
+    return function() {
+        
+    };
+};
+
+const counter = createCounter(10)
+counter() 
+counter()
+counter()
+console.log(counter()) // 13
+console.log(counter()) // 14

example/js/2626.js

@@ -0,0 +1,42 @@
+/**
+ * 2626. Array Reduce Transformation
+ * https://leetcode.com/problems/array-reduce-transformation/
+ * Difficulty: Easy
+ *
+ * Given an integer array nums, a reducer function fn, and an initial value init, return the final
+ * result obtained by executing the fn function on each element of the array, sequentially,
+ * passing in the return value from the calculation on the preceding element.
+ *
+ * This result is achieved through the following operations: val = fn(init, nums[0]),
+ * val = fn(val, nums[1]), val = fn(val, nums[2]), ... until every element in the array has been
+ * processed. The ultimate value of val is then returned.
+ *
+ * If the length of the array is 0, the function should return init.
+ *
+ * Please solve it without using the built-in Array.reduce method.
+ */
+
+/**
+ * @param {number[]} nums
+ * @param {Function} fn
+ * @param {number} init
+ * @return {number}
+ */
+var reduce = function(nums, fn, init) {
+
+};
+
+
+function sum1(accum, curr) { return accum + curr; }
+ex1 = reduce([1,2,3,4], sum1, 0)
+
+function sum2(accum, curr) { return accum + curr * curr; }
+ex2 = reduce([1,2,3,4], sum2, 100)
+
+function sum3(accum, curr) { return 0; }
+ex3 = reduce([], sum3, 25)
+
+console.log(ex1) // 10
+console.log(ex2) // 130
+console.log(ex3) // 25
+  

example/js/2629.js

@@ -0,0 +1,40 @@
+/**
+ * 2629. Function Composition
+ * https://leetcode.com/problems/function-composition/
+ * Difficulty: Easy
+ *
+ * Given an array of functions [f1, f2, f3, ..., fn], return a new function fn that is the function
+ * composition of the array of functions.
+ *
+ * The function composition of [f(x), g(x), h(x)] is fn(x) = f(g(h(x))).
+ *
+ * The function composition of an empty list of functions is the identity function f(x) = x.
+ *
+ * You may assume each function in the array accepts one integer as input and returns one integer
+ * as output.
+ */
+
+/**
+ * @param {Function[]} functions
+ * @return {Function}
+ */
+var compose = function(functions) {
+    
+    return function(x) {
+        
+    }
+};
+
+  
+functions1 = [x => x + 1, x => x * x, x => 2 * x]
+ex1 = compose(functions1)(4)
+
+functions2 = [x => 10 * x, x => 10 * x, x => 10 * x]
+ex2 = compose(functions2)(1)
+
+functions3 = []
+ex3 = compose(functions3)(42)
+
+console.log(ex1) // 65
+console.log(ex2) // 1000
+console.log(ex3) // 42

example/js/2634.js

@@ -0,0 +1,41 @@
+/**
+ * 2634. Filter Elements from Array
+ * https://leetcode.com/problems/filter-elements-from-array/
+ * Difficulty: Easy
+ *
+ * Given an integer array arr and a filtering function fn, return a filtered array filteredArr.
+ *
+ * The fn function takes one or two arguments:
+ * arr[i] - number from the arr
+ * i - index of arr[i]
+ *
+ * filteredArr should only contain the elements from the arr for which the expression
+ * fn(arr[i], i) evaluates to a truthy value. A truthy value is a value where
+ * Boolean(value) returns true.
+ *
+ * Please solve it without the built-in Array.filter method.
+ */
+
+/**
+ * @param {number[]} arr
+ * @param {Function} fn
+ * @return {number[]}
+ */
+var filter = function(arr, fn) {
+
+};
+
+
+fn1 = function greaterThan10(n) { return n > 10; }
+ex1 = filter([0,10,20,30], fn1)
+
+fn2 = function firstIndex(n, i) { return i === 0; }
+ex2 = filter([1,2,3], fn2)
+
+fn3 = function plusOne(n) { return n + 1 }
+ex3 = filter([-2,-1,0,1,2], fn3)
+
+console.log(ex1) // [20, 30]
+console.log(ex2) // [1]
+console.log(ex3) // [-2,0,1,2]
+  

example/js/2635.js

@@ -0,0 +1,37 @@
+/**
+ * 2635. Apply Transform Over Each Element in Array
+ * https://leetcode.com/problems/apply-transform-over-each-element-in-array/
+ * Difficulty: Easy
+ *
+ * Given an integer array arr and a mapping function fn, return a new array with a transformation
+ * applied to each element.
+ *
+ * The returned array should be created such that returnedArray[i] = fn(arr[i], i).
+ *
+ * Please solve it without the built-in Array.map method.
+ */
+
+/**
+ * @param {number[]} arr
+ * @param {Function} fn
+ * @return {number[]}
+ */
+var map = function(arr, fn) {
+
+};
+
+const arr = [1,2,3]
+
+fn1 = function plusone(n) { return n + 1; }
+ex1 = map(arr, fn1)
+
+fn2 = function plusI(n, i) { return n + i; }
+ex2 = map(arr, fn2)
+
+fn3 = function constant() { return 42; }
+ex3 = map(arr, fn3)
+
+console.log(ex1)
+console.log(ex2)
+console.log(ex3)
+  

example/js/2655.js

@@ -0,0 +1,32 @@
+/**
+ * 2665. Counter II
+ * https://leetcode.com/problems/counter-ii/
+ * Difficulty: Easy
+ *
+ * Write a function createCounter. It should accept an initial integer init.
+ * It should return an object with three functions.
+ *
+ * The three functions are:
+ * - increment() increases the current value by 1 and then returns it.
+ * - decrement() reduces the current value by 1 and then returns it.
+ * - reset() sets the current value to init and then returns it.
+ */
+
+/**
+ * @param {integer} init
+ * @return { increment: Function, decrement: Function, reset: Function }
+ */
+var createCounter = function(init) {
+
+};
+
+const counter = createCounter(5)
+// counter.increment(); // 6
+// counter.reset(); // 5
+// counter.decrement(); // 4
+
+console.log(counter.increment()) // 6
+console.log(counter.increment()) // 7
+console.log(counter.reset()) // 5
+console.log(counter.decrement()) // 4
+  

example/js/2667.js

@@ -0,0 +1,23 @@
+/**
+ * 2667. Create Hello World Function
+ * https://leetcode.com/problems/create-hello-world-function/
+ * Difficulty: Easy
+ *
+ * Write a function createHelloWorld. It should return a new function that
+ * always returns "Hello World".
+ */
+
+/**
+ * @return {Function}
+ */
+var createHelloWorld = function() {
+    
+    return function(...args) {
+        
+    }
+};
+
+const f = createHelloWorld();
+f();
+
+console.log(f()) // "Hello World"

example/js/2704.js

@@ -0,0 +1,27 @@
+/**
+ * 2704. To Be Or Not To Be
+ * https://leetcode.com/problems/to-be-or-not-to-be/
+ * Difficulty: Easy
+ *
+ * Write a function expect that helps developers test their code. It should take in any
+ * value val and return an object with the following two functions.
+ *
+ * - toBe(val) accepts another value and returns true if the two values === each other.
+ *   If they are not equal, it should throw an error "Not Equal".
+ * - notToBe(val) accepts another value and returns true if the two values !== each
+ *   other. If they are equal, it should throw an error "Equal".
+ */
+
+/**
+ * @param {string} val
+ * @return {Object}
+ */
+var expect = function(val) {
+
+};
+  
+// expect(5).toBe(5); // true
+// expect(5).notToBe(5); // throws "Equal"
+
+console.log(expect(5).toBe(5))
+console.log(expect(5).notToBe(5))