์ ์ ๋ฆฌ์คํธ num_list์ ์ ์ n์ด ์ฃผ์ด์ง ๋, num_list์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ๋ง์ง๋ง ์์๊น์ง n๊ฐ ๊ฐ๊ฒฉ์ผ๋ก ์ ์ฅ๋์ด์๋ ์์๋ค์ ์ฐจ๋ก๋ก ๋ด์ ๋ฆฌ์คํธ๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
function solution(num_list, n) {
let result = []
for(let i = 0; i < num_list.length; i+=n ){
result.push(num_list[i]);
}
return result;
}
const solution = (num_list, n) =>
num_list.filter((_, idx) => !(idx % n))
for๋ฌธ์ด ์๋ filter๋ก ํด๊ฒฐ!
ํด๋น ์์์ ์ธ๋ฑ์ค๊ฐ ์ง์๊ฐ ์๋ ์ ๋ค๋ง ํํฐ๋ง.
์ธ๋๋ฐ ๋ณ์
์ธ๋๋ฐ๋ก ํ์ํ ์ธ์๋ ์ฌ์ฉํ์ง ์๋ ๋ณ์๋ผ๋ ์๋ฏธ
ํจ์์ ๋งค๊ฐ๋ณ์๋ก ์ธ๋๋ฐ( _
)๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ JavaScript ๊ฐ๋ฐ์๋ค์ ๊ด์ต์ด๋ผ๊ณ ํ๋ค!
์ฆ, ์ด๋ค ํจ์์ ์ฒซ ๋ฒ์งธ ๋งค๊ฐ๋ณ์๊ฐ ์ค์ํ์ง ์๋ค๋ ๊ฒ์ ํํ!
_
= ๊ทธ ์์์ ๊ฐ์ด๋ค. ํ์ง๋ง ๊ทธ ๊ฐ์ ์ ์ ์ฝ๋์์ ์ฌ์ฉ๋์ง ์๊ณ ์ธ๋ฑ์ค๋ง ํจ์ ์ฐ์ฐ์ ์ฌ์ฉ๋๋, ๊ตณ์ด ํ์์๋ ๋ณ์์ด๊ธฐ ๋๋ฌธ์ ์ธ๋๋ฐ๋ก ์ฒ๋ฆฌํ ๊ฒ! ์คํธ๋ผ!! ์ ์ n๊ณผ ๋ฌธ์์ด control์ด ์ฃผ์ด์ง๋๋ค. control์ "w", "a", "s", "d"์ 4๊ฐ์ ๋ฌธ์๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, control์ ์์์๋ถํฐ ์์๋๋ก ๋ฌธ์์ ๋ฐ๋ผ n์ ๊ฐ์ ๋ฐ๊ฟ๋๋ค.
"w" : n์ด 1 ์ปค์ง๋๋ค.
"s" : n์ด 1 ์์์ง๋๋ค.
"d" : n์ด 10 ์ปค์ง๋๋ค.
"a" : n์ด 10 ์์์ง๋๋ค.
์ ๊ท์น์ ๋ฐ๋ผ n์ ๋ฐ๊ฟจ์ ๋ ๊ฐ์ฅ ๋ง์ง๋ง์ ๋์ค๋ n์ ๊ฐ์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
function solution(n, control) {
let copyN = n;
for(let i of control){
i === 'w' ? copyN++ : i === 's' ? copyN-- :
i === 'd' ? copyN += 10
: i === 'a' ? copyN -= 10 : copyN
}
return copyN;
}
const operations = {
w: (n) => n + 1,
s: (n) => n - 1,
d: (n) => n + 10,
a: (n) => n - 10,
};
function solution(n, control) {
return [...control].reduce((prev, op) => operations[op](prev), n);
}
control
๋ฐฐ์ด์ reduce
ํจ์๋ฅผ ์ฌ์ฉ
์๋ ์ฝ๋: operations
๋ผ๋ ๊ฐ์ฒด๋ฅผ ์ ์ธํด์ reduce
์ ํจ์ ์ธ์ ์ฐ์ฐ์ op
๋ณ์๋ฅผ key
๊ฐ์ผ๋ก ์ฌ์ฉํด์ ์ฐ์ฐ
์๊ฐ์ง๋ ๋ชป ํ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ ์ ์ ํ๋ค! ํจ์๋ฅผ ๋ด์ ๊ฐ์ฒด์ reduce
ํจ์๋ฅผ ์ด๋ ๊ฒ๋ ์ฎ์ด์ ์ฌ์ฉํ ์ ์๊ตฌ๋
์ ์ ๋ฐฐ์ด arr์ ์์ฐ์ k๊ฐ ์ฃผ์ด์ง๋๋ค.
๋ง์ฝ k๊ฐ ํ์๋ผ๋ฉด arr์ ๋ชจ๋ ์์์ k๋ฅผ ๊ณฑํ๊ณ , k๊ฐ ์ง์๋ผ๋ฉด arr์ ๋ชจ๋ ์์์ k๋ฅผ ๋ํฉ๋๋ค.
์ด๋ฌํ ๋ณํ์ ๋ง์น ํ์ arr๋ฅผ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
function solution(arr, k) {
let result = [...arr];
if(k % 2 === 0){
return result.map((num) => num + k )
}
else{
return result.map((num) => num * k )
}
}
const solution = (arr, k) => arr.map(v => k % 2 ? v * k : v + k)
๋ด ์ฝ๋๋ ๋ก์ง์ ๊ฐ์๋ฐ ์ผํญ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด์ ํจ์ฌ ๋ ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ์ ์ ๊ธฐ์ต์ ๋จ๋๋ค.
if else ๋์ ์ผํญ ์ฐ์ฐ์ ์ฌ์ฉ์ ์ต์ํ๊ฒ ํ์.
๋ฌธ์์ด์ ์ซ์๋ก ๋ฐ๊ฟ๋, Number()๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ์์ ๋ถํธ๋ฅผ ๋ถ์ฌ์ฃผ๋ฉด ์ซ์๋ก ์ธ์ํ๋ค!
ex. +str
= Number(str)
/ n+""
( โก ๋ฌธ์๋ฅผ ์ซ์๋ก)
replaceAll
์ ์กด์ฌ๋ฅผ ์์ง ๋ง์.
replace(/V/g, 'L')
= replaceAll('V', 'L')
์ ๊ณฑ๊ทผ ๋ฐํํ๋ Math ํจ์
Math.pow(base, exponent)
= base^exponent