희제 블로그

문제

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.

예제

Arrays.map을 구현하는 함수로써, arr 원소들을 돌며 각각 fn(n) 값을 구해 새로운 배열에 넣는다.

위 예제의 경우 plusI의 두번째 파라미터로 인덱스가 들어가는 것에 유의한다.

constant() 함수가 파라미터에 상관없이 42를 반환하기 때문에 답은 arr의 길이만큼 42로 채워져 있는 배열이 된다.

코드

/**
 * @param {number[]} arr
 * @param {Function} fn
 * @return {number[]}
 */
var map = function(arr, fn) {
    const mappedArr = []
    
    arr.forEach((el, idx) => {
        mappedArr.push(fn(el, idx));
    })
    
    return mappedArr;
};

새로운 배열 mappedArr를 생성한 뒤, arr를 순회하며 각각의 원소와 인덱스값을 fn 함수에 넣는다. 이후 매번 반환된 값을 mappedArr에 넣고 순환이 종료되면 반환시킨다.

문제

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.

예제

arr, fn이 주어지면 arr의 각 원소를 fn 함수에 넣은 뒤 반환값이 True일 경우에만 Output 배열에 추가시킨다.

fn 함수에서 두 개의 파라미터를 필요로 할 땐, 첫 번째 인자로 arr의 각 원소를, 두 번째 인자로 각 원소의 인덱스 번호 i를 넣는다. 위 예제의 경우 인덱스 번호가 0인 경우에만 Output 배열에 추가된다.

0과 같은 Falsy한 값도 함수에서 걸러져야 한다. arr의 원소들 중 -1의 경우, plusOne 함수에 들어갔을 때 return 값이 0이 되어 Output 배열에 추가되지 않는다.

코드

/**
 * @param {number[]} arr
 * @param {Function} fn
 * @return {number[]}
 */
var filter = function(arr, fn) {
    const filteredArr = [];
    
    for (let i = 0; i < arr.length; i++) {
        if (fn(arr[i], i)) {
            filteredArr.push(arr[i]);
        }
    }
    
    return filteredArr;
};

arr에 대해 순회하면서 fn 함수에 원소와 인덱스값을 넣고 반환값을 확인한다. 만약 반환값이 True이면 filteredArr에 추가하고, 반환값이 False이면 추가하지 않는다.

문제

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.

예제

functions 배열에서 역순으로 함수들에 x을 넣어 나온 값을 x로 갱신시킨다.

마찬가지로 역순으로 함수들에 x를 삽입 후 나온 값으로 갱신시킨다.

functions 배열이 비어있을 경우, 정답은 항상 x이다.

코드

/**
 * @param {Function[]} functions
 * @return {Function}
 */
var compose = function(functions) {
    return function(x) {
        for (let i = functions.length - 1; i >= 0; i--) {
            x = functions[i](x);
        }
        
        return x;
    }
};

/**
 * const fn = compose([x => x + 1, x => 2 * x])
 * fn(4) // 9
 */

함수들이 들어있는 functions 배열을 역순으로 순회하며 x값을 넣은 후 반환된 값으로 x를 업데이트한다.

모든 함수를 순회하게 되면 문제에서 요구하는 값을 계산할 수 있다.

문제

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.

예제

초기값과 숫자들, 그리고 함수가 주어지면 Array.reduce처럼 누적값과 숫자가 함수 내에서 연산된 뒤 반환된 값을 누적값으로 업데이트한다.

위 예제의 경우 먼저 fn 함수에 의해 초기값과 num[0]이 더해져 나온 값인 1이 누적값으로 업데이트되고,

그 누적값과 num[1]이 더해져 나온 값인 3이 누적값으로 업데이트되는 방식으로 nums 배열을 모두 순회할 때까지 진행된다.

위 예제도 예제 1과 같은 방식이지만, fn 함수 내부 연산이 curr의 제곱값을 더하는 점에서 다르다.

nums가 빈 배열일 경우, 정답은 항상 초기값이다.

코드

/**
 * @param {number[]} nums
 * @param {Function} fn
 * @param {number} init
 * @return {number}
 */
var reduce = function(nums, fn, init) {
    let value = init;
    for (let num of nums) {
        value = fn(value, num);
    }
    
    return value;
};

먼저 누적값을 담을 변수 value을 선언하고 초기값인 init으로 초기화한다.

이후 nums 배열을 순회하면서 value값과 num을 fn 함수에 넣고 반환된 값으로 value를 업데이트해준다.

마지막으로 value를 반환해주면 문제에서 요구했던 함수를 구현할 수 있다!

문제

Given a positive integer millis, write an asynchronous function that sleeps for millis milliseconds. It can resolve any value.

예제

100ms 후 resolve되는 promise 객체를 반환해야 한다.

위 예제의 경우 200ms 후에 resolve되는 promise를 반환해야 한다.

코드

/**
 * @param {number} millis
 * @return {Promise}
 */
async function sleep(millis) {
    return new Promise((resolve => setTimeout(resolve, millis)))
}

/** 
 * let t = Date.now()
 * sleep(100).then(() => console.log(Date.now() - t)) // 100
 */

sleep 함수 실행 시 Promise 객체를 반환하는데, 해당 객체는 setTimeout 함수를 이용하여 millis 밀리초 후 resolve된다. Promise 객체에 대해 더 공부해보아야겠다..!

문제

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).

예제

위 예제의 경우 처음에 -2를 반환하고, 그 뒤론 각각의 호출마다 1씩 증가한 값을 반환한다.

코드

/**
 * @param {number} n
 * @return {Function} counter
 */
var createCounter = function(n) {
    let cnt = n;
    return function() {
        return cnt++;
    };
};

/** 
 * const counter = createCounter(10)
 * counter() // 10
 * counter() // 11
 * counter() // 12
 */

cnt라는 변수를 n으로 초기화한 후, 클로저를 이용하여 매 호출마다 cnt를 반환한 뒤 1만큼 증가시킨다.

문제

Write code that enhances all arrays such that you can call the array.last() method on any array and it will return the last element. If there are no elements in the array, it should return -1.

You may assume the array is the output of JSON.parse.

예제

nums.last() 호출 시 마지막 원소인 3을 반환해야 한다.

배열 내에 원소가 없을 경우, -1를 반환한다.

코드

/**
 * @return {null|boolean|number|string|Array|Object}
 */

Array.prototype.last = function() {
    if (this.length === 0) {
        return -1;
    }
    
    return this[this.length - 1];
};

/**
 * const arr = [1, 2, 3];
 * arr.last(); // 3
 */

현재 배열의 길이가 0인 경우, 즉 배열 내에 원소가 없는 경우 -1을 반환한다. 그렇지 않다면 length 메소드를 이용하여 배열의 마지막 원소를 반환한다.