tiling ์ธ๋ก ๊ธธ์ด 2, ๊ฐ๋ก ๊ธธ์ด n์ธ 2 x n ๋ณด๋๊ฐ ์์ต๋๋ค. 2 x 1 ํฌ๊ธฐ์ ํ์ผ์ ๊ฐ์ง๊ณ ์ด ๋ณด๋๋ฅผ ์ฑ์ฐ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค. ์ด๋ฐ ๊ฒฝ์ฐ์ ์ ๋ฌธ์ ๋ ์ผ๋จ ์์ ์๋ฅผ ์์ ๊ณ์ฐํด์ ๊ท์น์ ์ฐพ์๊ฐ๋ ๊ฒ์ด ๋น ๋ฅด๋ค. ๋ชจ์๋๊ณ ๋ณด๋ ๊ท์น์ฑ์ด ๋ณด์ธ๋ค n=1 -> 1 n=2 -> 2 n=3 -> 3 n=4 -> 5 n=5 -> 8 ... ์ธ๋ก์ ๊ธธ์ด๋ ๊ณ ์ ๋ ์ฑ๋ก ๊ฐ๋ก์ ๊ธธ์ด๋ง ๋์ด๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์, ์ชผ๊ฐ์ด์ ์๊ฐํ๋ฉด ํธ๋ฆฌํ๋ค. ๊ฒฐ๊ตญ ํ ์นธ์ ์ฐจ์งํ๋ 2x1์ ์ ์ธํ ๋๋จธ์ง ๋ชจ์์ด ๋ฐ๋ก ์ (n-1)๊ณผ ๊ฐ๊ณ , ๋ ์นธ์ ์ฐจ์งํ๋ ์ต์ 2x2๋ฅผ ์ ์ธํ ๋๋จธ์ง ๋ชจ์์ด (n-2)์ ๊ฐ๋ค๋ ๊ฒ์ ์ ์ ์๋ค. ์ฆ ํผ๋ณด๋์น์ ์์ ์ ์ฌํ ์์ด์ด ๋๋ ๊ฒ. ๋จ์ํ ์ฌ๊ท๋ก ๋ํ๋ด์ด ๋ณด๋ฉด let t..
isSubsetOf ๋ ๊ฐ์ ๋ฐฐ์ด(base, sample)์ ์
๋ ฅ๋ฐ์ sample์ด base์ ๋ถ๋ถ์งํฉ์ธ์ง ์ฌ๋ถ๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค. const isSubsetOf = function (base, sample) { return sample.every((number) => base.includes(number)); } array ๋งค์๋์ธ every, inclueds์ฌ์ฉ. -> ์๊ฐ ์ด๊ณผ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ ํ๊ธฐ ์ํด ์ผ๋จ ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค. base.sort((a, b) => a - b); sample.sort((a, b) => a - b); for(let i = 0; i < base.length; i++) { if(base[i] === sample[0]) { sample.shift(); } } i..
bubbleSort ์ ์๋ฅผ ์์๋ก ๊ฐ๋ ๋ฐฐ์ด์ ์
๋ ฅ๋ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ ๋ฆฌํดํด์ผ ํฉ๋๋ค. ๋ฒ๋ธ ์ ๋ ฌ(bubble sort)์ ์ฌ๋ฌ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ(์ฝ์
์ ๋ ฌ, ํต ์ ๋ ฌ, ๋ณํฉ ์ ๋ ฌ, ๊ธฐ์ ์ ๋ ฌ ๋ฑ) ์ค ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์
๋๋ค. ๋ฒ๋ธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์๋์ ๊ฐ์ต๋๋ค. ์ฒซ ๋ฒ์งธ ์์๊ฐ ๋ ๋ฒ์งธ ์์๋ณด๋ค ํฌ๋ฉด, ๋ ์์์ ์์น๋ฅผ ๋ฐ๊ฟ๋๋ค. (swap) ๋ ๋ฒ์งธ ์์์ ์ธ ๋ฒ์งธ ์์๋ณด๋ค ํฌ๋ฉด, ๋ ์์์ ์์น๋ฅผ ๋ฐ๊ฟ๋๋ค. (swap) 1, 2๋ฅผ ๋ง์ง๋ง๊น์ง ๋ฐ๋ณตํฉ๋๋ค. (๋ง์ง๋ง์์ ๋ ๋ฒ์งธ ์์์ ๋ง์ง๋ง ์์๋ฅผ ๋น๊ต) 1~3์ ๊ณผ์ ์ ํ ๋ฒ ๊ฑฐ์น๊ฒ ๋๋ฉด, ๊ฐ์ฅ ํฐ ์์๊ฐ ๋ฐฐ์ด์ ๋ง์ง๋ง์ผ๋ก ๋ฐ๋ ค๋ฉ๋๋ค. 1~3์ ๊ณผ์ ์ ์ฒซ ์์๋ถํฐ ๋ค์ ๋ฐ๋ณตํฉ๋๋ค. 5๋ฅผ ํตํด ๋ ๋ฒ์งธ๋ก ํฐ ์์๊ฐ ๋ฐฐ์ด์ ๋ง์ง๋ง ๋ฐ๋ก ๋ ๋ฒ..
fibonacci ์๋์ ๊ฐ์ด ์ ์๋ ํผ๋ณด๋์น ์์ด ์ค n๋ฒ์งธ ํญ์ ์๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค. (๋ฐ๋ณต๋ฌธ ์ฌ์ฉx) 0๋ฒ์งธ ํผ๋ณด๋์น ์๋ 0์ด๊ณ , 1๋ฒ์งธ ํผ๋ณด๋์น ์๋ 1์
๋๋ค. ๊ทธ ๋ค์ 2๋ฒ์งธ ํผ๋ณด๋์น ์๋ถํฐ๋ ๋ฐ๋ก ์ง์ ์ ๋ ํผ๋ณด๋์น ์์ ํฉ์ผ๋ก ์ ์ํฉ๋๋ค. 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ... 7๋ฒ์งธ ํผ๋ณด๋์น ์๊ฐ ๋์ค๋ ๊ณผ์ (n=7)์ ๋์ดํด๋ณด๋ฉด, 0 1 1 = 0 + 1 2 = 1 + 1 3 = 2 + 1 5 = 3 + 2 8 = 5 + 3 13 = 8 + 5 ์ด๋ฅผ ํจ์๋ก ํํํด๋ณด๋ฉด f(n) = f(n-1) + f(n-2) n>=2์ธ ์์ฐ์, f(0) = 0 , f(1) = 1 ์ฆ f(n)์ ์ซ์๋ฅผ ์
๋ ฅ๋ฐ์์ ์ด n+1 ๊ฐ๋ฅผ ๋ํ๊ฒ ๋๋ ํจ์๊ฐ ๋๋ค. functio..
largestProductOfThree ์ ์๋ฅผ ์์๋ก ๊ฐ๋ ๋ฐฐ์ด์ ์
๋ ฅ๋ฐ์ 3๊ฐ์ ์์๋ฅผ ๊ณฑํด ๋์ฌ ์ ์๋ ์ต๋๊ฐ์ ๋ฆฌํดํด์ผ ํฉ๋๋ค. ์น์
3๋ค์ด ๊ธ๊ฒฉํ ์ด๋ ค์์ง ๋์ด๋์ ์คํจ๋ง๋ก ํ๋ ๋ง์ ๊ธฐ๋ถ.. ใ
_ใ
์น์
2๋ถํฐ ๋ค์ ์์ํ๊ฒ ๋ ๋ฐ์ผ๋ฆฌ์ฝ๋ฉ. ์ผ๋จ ์ฒ์์ ์๊ฐํ๋ ๊ฒ์, ์์์ 0์ด ์์ฌ์์ผ๋ ์ด๊ฑธ ์ฃผ์ํด์ผ๊ฒ ๋ค ์ถ์๋ ๊ฑฐ์์. // ๋ฐฐ์ด ์ค (์ ๋๊ฐ์ด) ๊ฐ์ฅ ํฐ ์ 3๊ฐ? // ์์๋ ์ง์ ๊ฐ์ฌ์ผ ํจ. // 3๊ฐ ์ค์ 0์ ์์ด์ผ ํจ. let arr = [-1, 8, 0, -134, -44] arr.map(Math.abs) = [1, 8, 0, 134, 44] arr.map(Math.abs).sort() = [0, 1, 134, 44, 8] let plus = arr.map(Math.abs) plu..
25๋ฒ. tiling ์ธ๋ก ๊ธธ์ด 2, ๊ฐ๋ก ๊ธธ์ด n์ธ 2 x n ๋ณด๋๊ฐ ์์ต๋๋ค. 2 x 1 ํฌ๊ธฐ์ ํ์ผ์ ๊ฐ์ง๊ณ ์ด ๋ณด๋๋ฅผ ์ฑ์ฐ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค. ๋ด๊ฐ ์ด ๋ต let tiling = function (n) { // 2 x 4 ๋ณด๋์ ํ์ผ์ ๋๋ ๊ฒฝ์ฐ // 1) ์ฒ์์ ์ธ๋ก๋ก ํ๋ ๋๋ ๊ฒฝ์ฐ : 2 x 1 + 2 x 3 // 2) ๊ฐ๋ก๋ก ๋๋ ๊ฒฝ์ฐ (๋ฐ์๋ ๊ฐ๋ก๋ก ๋๊ฒ ๋จ) : 2 x 2 + 2 x 2 // => ์ฆ n=4 ์ผ ๋ ๊ฒฝ์ฐ์ ์ : n = 2, 3 ์ผ ๋๋ฅผ ๋ํ ๊ฒ (์ฌ๊ท) let arr = [0,1,2]; const boxTiling = (n) => { if(arr[n]) return arr[n]; return arr[n] = boxTiling(n-1) + boxTili..
10๋ฒ. ๋ฌธ์์ด์ ์
๋ ฅ๋ฐ์ ์ฐ์๋ ํ์๋ฆฌ ํ์ ์ซ์ ์ฌ์ด์ '-'๋ฅผ ์ถ๊ฐํ ๋ฌธ์์ด์ ๋ฆฌํดํด์ผ ํฉ๋๋ค. function insertDash(str) { let result = str[0] for (let i = 1; i
9๋ฒ. ๋ฌธ์์ด์ ์
๋ ฅ๋ฐ์ ๋ฌธ์์ด ๋ด์ ์๋ ์ค ํ๋๊ฐ ์กด์ฌํ๋์ง ์ฌ๋ถ๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค. 'a'๋ก ์์ํด์ 'b'๋ก ๋๋๋ ๊ธธ์ด 5์ ๋ฌธ์์ด 'b'๋ก ์์ํด์ 'a'๋ก ๋๋๋ ๊ธธ์ด 5์ ๋ฌธ์์ด function ABCheck(str) { let str1 = str.toLowerCase() for (let i = 0; i
8๋ฒ. ๋ฌธ์์ด์ ์
๋ ฅ๋ฐ์ ํด๋น ๋ฌธ์์ด์ ๋ฑ์ฅํ๋ ๋ ์นธ์ ๊ณต๋ฐฑ์ ๋ชจ๋ ํ ์นธ์ ๊ณต๋ฐฑ์ผ๋ก ๋ฐ๊พผ ๋ฌธ์์ด์ ๋ฆฌํดํด์ผ ํฉ๋๋ค. function convertDoubleSpaceToSingle(str) { return str.replace(/ /g, ' ') } ๋ณด์๋ง์ replace๋ก ํ๋ฉด ๋๊ฒ ๋ค๊ณ ์๊ฐํ๋๋ฐ.. ์ฌ์ค replace๊ฐ ์๊ฐ์ ์์ฒญ ์ก์๋จน๋๋ค๋ ์ด์ผ๊ธฐ๋ฅผ ๋ค์ด์ ใ
ใ
์ซ ์ฐ์ฐํ์ผ๋ ๊ทธ๋๋ ๋นจ๋ฆฌ ํ์ด์ผ์ง ์ถ์ด์ ์ด๋๋ก ์ ์ถ.. ์คํฐ๋์ ๋ถ๋ค์ splitํด์ ํ๊ฑฐ๋, ๋ ํผ๋ฐ์ค๋ for๋ฌธ์ผ๋ก ํ์๊ธธ๋ ๋๋ ํ๋ฒ์ฉ ๋ค์ ํ์ด๋ณด์์ผ ๊ฒ ๋ค
7๋ฒ. 2์ฐจ์ ๋ฐฐ์ด(๋ฐฐ์ด์ ์์๋ก ๊ฐ๋ ๋ฐฐ์ด)์ ์
๋ ฅ๋ฐ์ ๊ฐ ๋ฐฐ์ด์ ์ด์ฉํด ๋ง๋ ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค. function convertListToObject(arr) { let obj = {}; for (let i in arr) { if (arr[i].length !== 0 && !(arr[i][0] in obj)){ obj[arr[i][0]]=arr[i][1] } } return obj } ๋น ๊ฐ์ฒด๋ฅผ ์ง์ ํด์ฃผ๊ณ , ๋ฐฐ์ด์ ์์์ ๋น ๋ฐฐ์ด์ด ์๋๊ณ , ์๋ก ๋ง๋ค ๊ฐ์ฒด๋ด์ ๋ฐฐ์ด๋ด ๋ฐฐ์ด์ ์ฒซ๋ฒ์จฐ ๊ฐ์ฒด๊ฐ (์ค๋ณต๊ฐ์ผ ๊ฒฝ์ฐ ์ ์ธํ๊ธฐ ์ํด) ์ด ์์ ๊ฒฝ์ฐ ๊ทธ ๊ฐ์ฒด๋ฅผ ์ง์ ํด์ค function convertListToObject(arr) { let result = {}; for (let i = 0; i < arr.leng..
6๋ฒ. ๋ฌธ์์ด์ ์
๋ ฅ๋ฐ์ ๋ฌธ์์ด์ ๊ตฌ์ฑํ๋ ๊ฐ ๋จ์ด์ ์ฒซ ๊ธ์๊ฐ ๋๋ฌธ์์ธ ๋ฌธ์์ด์ ๋ฆฌํดํด์ผ ํฉ๋๋ค. function letterCapitalize(str) { let arr = str.split(' ') for (let i = 0; i "nil" console.log(text.substr(2,3)); // => "nil" ๋ง์ฝ indexEnd ๊ฐ ์๋ต๋ ๊ฒฝ์ฐ, substring() ๋ฌธ์์ด์ ๋๊น์ง ๋ชจ๋ ๋ฌธ์๋ฅผ ์ถ์ถํฉ๋๋ค. ๋ง์ฝ indexStart ๊ฐ indexEnd์ ๊ฐ์ ๊ฒฝ์ฐ, substring() ๋น ๋ฌธ์์ด์ ๋ฐํํฉ๋๋ค. ๋ง์ฝ indexStart ๊ฐ indexEnd๋ณด๋ค ํฐ ๊ฒฝ์ฐ, substring() ๋ฉ์๋๋ ๋ง์น ๋ ๊ฐ์ ์ธ์๋ฅผ ๋ฐ๊พผ ๋ฏ ์๋ํ๊ฒ ๋ฉ๋๋ค. .slice() var str = 'The ..
5๋ฒ. ๋ฌธ์์ด์ ์
๋ ฅ๋ฐ์ ์์๊ฐ ๋ค์งํ ๋ฌธ์์ด์ ๋ฆฌํดํด์ผ ํฉ๋๋ค. - ๋ฐฐ์ด์ ์ด์ฉํด์ ๋ค์ง๋ ๋ฐฉ๋ฒ ์ด์ฉ function firstReverse(str) { return str.split('').reverse().join() } 'ti od nac uoy'์(๋ฅผ) ์
๋ ฅ๋ฐ์ ๊ฒฝ์ฐ, 'you can do it'์(๋ฅผ) ๋ฆฌํดํด์ผ ํฉ๋๋ค Test Result AssertionError: expected 'y,o,u, ,c,a,n, ,d,o, ,i,t' to deeply equal 'you can do it' ์ด๋ฐ ์์ผ๋ก ์ถ๋ ฅ๋์๋ค.. join() ์ ๋ํ ์ดํด๊ฐ ๋ถ์กฑํ๋ ๊ฒ์ผ๋ก.. .join() var a = ['๋ฐ๋', '๋น', '๋ถ']; var myVar1 = a.join(); // myVar1์ '๋ฐ๋,๋น,..