๋ฌธ์ ๋ด์ฉ ์ด๐๐ปโ๏ธ function solution(s) { const convertedArr = Array.from(s); const result = convertedArr.map((v) => Number(v)); if (s.length === 4 || s.length === 6) { return result.includes(NaN) ? false : true; } return false; } /* (ํ์ด) ๋ฌธ์์ด s๋ฅผ ๋ฐฐ์ด์ ๋ฃ๊ณ map๋ฉ์๋๋ก ๊ฐ์ Numberํ์
์ผ๋ก ๋ณํ. ๋ฌธ์๋ -, ์์ ๋ฑ์ NaN ์ผ๋ก ๋์ค๋ฏ๋ก ์์๊ฐฏ์๊ฐ 4,6 ์ธ ๋ฐฐ์ด์ NaN๊ฐ ์๋ค๋ฉด false ์์ผ๋ฉด true */ ํ
์คํธ ์ผ์ด์ค 11๋ฒ์ด ๊ณ์ ์คํจํ๋ค. ๋ฌธ์ ๋ 3e6 ์ 3 * 10 ^ 6์ ์๋ฏธํ๋ค. Number๋ก..
FE๋ฅผ ํฅํดโโ
์๋ผํ ์คํ
๋ค์ค์ ์ฒด ์๋ผํ ์คํ
๋ค์ค์ ์ฒด๋ ์์ ์ฐพ๊ธฐ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. "์์"๋ 1๊ณผ ์์ ์ด์ธ์ ์์ฐ์๋ก๋ ๋๋ ์ ์๋ ์์ฐ์์ด๋ค. ( 2, 5, 7 ๋ฑ) 1~100๊น์ง์ ์ซ์๋ฅผ ๋์ด. ์์๊ฐ ์๋ 1์ ์ ๊ฑฐ. 2๋ฅผ ์ ์ธํ 2์ ๋ฐฐ์๋ฅผ ์ ๊ฑฐ. 3์ ์ ์ธํ 3์ ๋ฐฐ์๋ฅผ ์ ๊ฑฐ. 4์ ๋ฐฐ์๋ 2์ ๋ฐฐ์๋ก ์ด๋ฏธ ์ง์์ก์ผ๋ฏ๋ก 5๋ฅผ ์ ์ธํ 5์ ๋ฐฐ์๋ฅผ ์ ๊ฑฐํ๋ค. 6๋ํ 3์ ๋ฐฐ์๋ก ์ง์์ก์ผ๋ฏ๋ก 7์ ์ ์ธํ 7์ ๋ฐฐ์๋ฅผ ์ ๊ฑฐ. 11 ๋ถํฐ๋ 11^2 > 100 ์ด๊ธฐ์ ์ง์ธ ํ์๊ฐ ์๋ค. ์ด๋ฐ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ฃผ์ด์ง n์ดํ์ ์์๋ฅผ ์ฐพ๊ณ ์ถ์ ๋ ์ฌ์ฉํ ์ ์๋ค. ์๋ฐ์คํฌ๋ฆฝํธ๋ก ๊ตฌํ function solution(n) { //n + 1 ๊ฐ์ ์์๋ฅผ ๊ฐ์ง ๋ฐฐ์ด ์์ฑ ๋ชจ๋ true๋ก ๋ณ๊ฒฝ ํ ์์์ ์ธ๊ฐ 0,1 ์ false..
Learned ์๊ณ ๋ฆฌ์ฆ(์๋ผํ ์คํ
๋ค์ค์ ์ฒด, ๊ทธ๋ฆฌ๋ ๋ฑ) ์ ๋ํด ๋ฐฐ์ ๋ค. ๊ฐ์ ๋ฌธ์ ๋ฅผ ๋ค๋ฅธ๋ฐฉ์์ผ๋ก ํธ๋ ๊ฐ๋
์ ๋ฐฐ์ ๋ค. (Array.from ๋ฑ) reduce๊ฐ ์ฒ๋ฆฌ ๋๋ ๋ฐฉ์์ ๋ํด ๋ฐฐ์ ๋ค. Liked ์ฐธ๊ณ ๊ฐ ๋ ๋งํ ์ฝ๋๋ฅผ ์งฐ๋ค๐ ๋ถํธ์บ ํ ๋ณํํ๋ฉด์ ๋ฐ๋ฆฌ์ง ์๊ณ ์ ํด๋ด๊ณ ์๋ค. ์กฐ๊ธ์ด๋๋ง ์๊ณ ๋ฆฌ์ฆ์ ๋ํด ์๊ฒ๋๋ค. ์๊ฐ๋ถ๋ฐฐ๊ฐ ์ด๋์ ๋ ์ด๋ฃจ์ด์ง๊ณ ์๋ค. Lacked ๋ถํธ์บ ํ ํ๊ณ๋ก ์กฐ๊ธ ํจ์จ์ฑ๊ณผ ํด๋ฆฐํ ์ฝ๋์ ๋ํด ๊ณ ๋ฏผํ๋ ์๊ฐ์ด ์ ์ด์ก๋ค..๐ฅฒ (์ด๋๋ ๋ฏธ๋ฃจ์ง๋ง์) ์ํ์ ๊ฐ๋
์ด ํ์ํ ์๊ณ ๋ฆฌ์ฆ์ ์๋ฒฝํ๊ฒ ์ดํดํ์ง ๋ชปํ๋ค. ์ดํดํ๋๋ผ๋ ๊ทธ๊ฑธ ์ฝ๋์ ๋
น์ฌ๋ด๊ธฐ๊ฐ ์ฝ์ง์๋ค. Array.from์ ๊ณ ๋ฏผํด๋ดค์ง๋ง ์ต์
์ด ์ด๋ ต๊ณ ์ด๋ค ์ํฉ์์ ์ ์ ํ๊ฒ ์ฌ์ฉํด์ผํ ์ง ์์ง ์ ๋ชจ๋ฅด๊ฒ ๋ค..
๋ฌธ์ ๋ด์ฉ ํ์ด๐๐ปโ๏ธ function solution(d, budget) { let result = 0; d.sort((a, b) => a - b).reduce((acc, cur) => { if (budget >= acc + cur) { result++; } return acc + cur; }, 0); return result; } function solution(d, budget) { let result = 0; let sumEach = 0; d.sort((a, b) => a - b); for (i = 0; i = sumEach) { result++; } } return result; } /* (ํ์ด) 1. ๋ฐฐ์ด์..
๋ฌธ์ ๋ด์ฉ ํ์ด๐๐ปโ๏ธ function solution(arr, divisor) { const result = arr .filter((value) => value % divisor === 0) .sort((a, b) => a - b); return result.length === 0 ? [-1] : result; } /* (ํ์ด) arr ์ filter ๋ก ๋๋จธ์ง๊ฐ 0 ์ด ๋๋ ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก result์ ํ ๋น. ์ผํญ์ฐ์ฐ์๋ก ๋ฐฐ์ด์ด ๋น์ด์์ผ๋ฉด -1์ ๋ฆฌํดํด์คฌ๋ค. ๊ฐ์ด ์ ์์ธ์ง ๋ถ๋ฆฌ์ธ ๊ฐ์ผ๋ก ๋ฐํํด์ฃผ๋Number.isInteger()๋ฅผ ์ด์ฉํ ๋ฐฉ๋ฒ๋ ์๊ฐํด๋ดค๋๋ฐ ๊ฒฐ๊ตญ for๋ฌธ์ ์ฌ์ฉํด์ผํด์ ๊ฐ๋
์ฑ์ด ๋ ์ข์ fliter ์ฌ์ฉ. */ length === 0 ๋ณด๋ค๋ not์ฐ์ฐ์ ์ด์ฉํด์ !result..
์๊ฐ ๋ณต์ก๋๋ฅผ ๊ณ ๋ คํ ํ์ด? ๐ค ์ฝ๋ฉ ํ
์คํธ ๋ฌธ์ ๋ฅผ ์ฒ์ ํ์์ ๋ ๋ฌธ์ ๋ฅผ ํ๊ธฐ์ ๊ธ๊ธํ์ง๋ง ๋ง์ ํ
์คํธ์ ํต๊ณผํ๊ณ ๋ ํ ์ด ์ฝ๋๊ฐ ๋ง๋? ์ด๊ฒ ํจ์จ์ ์ธ๊ฐ?๋ผ๋ ์๊ฐ์ ํด๋ณธ ์ ์ด ์๋ค๋ฉด ์ด๋ฏธ ์๊ฐ ๋ณต์ก๋์ ๋ํด ๊ณ ๋ฏผํด ๋ณธ ๊ฒ์ด๋ ๋ค๋ฆ์๋ค! ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ณ ๋ คํ๋ค๋ ๊ฑด ์
๋ ฅ๊ฐ์ ๋ฐ๋ผ ๋ก์ง์ด ์คํ๋๋ ์๊ฐ์ด ์ฆ๊ฐํ๊ณ ๊ฐ์ํ๋ ์๊ฐ์ ๋น์จ์ ์ต์ํํ์ฌ ๊ตฌ์ฑํ๋ค๋ ๋ป์ด๋ค. ์๊ฐ ๋ณต์ก๋๋ 3๊ฐ์ง์ ํ๊ธฐ๋ฒ์ด ์๋๋ฐ Big-O(๋น
-์ค) -> ์ต์
์ ๊ณ ๋ ค ( ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ต๋๋ฅผ ๊ณ ๋ ค ) Big-Ω(๋น
-์ค๋ฉ๊ฐ) -> ์ต์ ์ ๊ณ ๋ ค ( ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ต์ ์ ๊ณ ๋ ค ) Big-θ(๋น
-์ธํ) -> ํ๊ท ์ ๊ณ ๋ ค ( ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ํ๊ท ์ ๊ณ ๋ ค ) ์๊ฐ ๋ณต์ก๋์์ ๊ฐ์ฅ ์์ฃผ ์ฌ์ฉ๋๋ ํ๊ธฐ๋ฒ์ ๋น
์ค ํ๊ธฐ๋ฒ์ผ๋ก ์ต์
์ ๊ณ ๋ คํด์ผ ํ๋ค...
๋ฌธ์ ๋ด์ฉ ํ์ด๐๐ปโ๏ธ function solution(a, b) { let result = [a, b]; if (a > b) { for (i = 1 + b; i acc + cur); } /* (ํ์ด) ๊ฐ ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ฐ๋ผ for๋ฌธ์ ๋๋ ค result ๋ฐฐ์ด์ ๊ฐ์ ๋ฃ์ด์ฃผ๊ณ reduce ๋ฉ์๋๋ฅผ ์ด์ฉํด ๊ฐ์ ํฉ์ฐํด์ return ํด์คฌ๋ค. ๊ฐ๋
์ฑ ์ข์ ์ฝ๋๋ ์๋๊ฑฐ ๊ฐ์๋ฐ..๐ค ๋ฌด์ธ๊ฐ ์ํ์ ๋ฐฉ๋ฒ์ด ์์๊ฑฐ ๊ฐ์๋ฐ ๋ ์ค๋ฅด์ง ์๋๋ค.. *..
๋ฌธ์ ๋ด์ฉ ํ์ด๐๐ปโ๏ธ function solution(price, money, count) { let result = 0; for (i = 1; i price * (idx + 1) ).reduce((acc, cur) => acc + cur); return sum - money > 0 ? sum - money : 0; } ๋๊ฐ์ง ๋ฐฉ๋ฒ์ ์ ์ผ์
จ๋๋ฐ Array.from ์ ์ด์ฉํ ํ์ด๋ฅผ ๊ฐ์ ธ์๋ค. ์ด๋ ๊ฒ ํธ๋ ๋ฐฉ๋ฒ๋ ์๋ค๋ ๊ฑธ ์์ง.