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..
Algorithm
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..
์๊ฐ ๋ณต์ก๋ O(์
๋ ฅ)O(1) < O(log n) < O(n) < O(n log n) < O(n^2) < O(2^2) < O(n!) ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ ์๋ก ์คํ ํ์๊ฐ ๋ง์, ์๊ฐ ๋ณต์ก๋๊ฐ ๋์ ๊ฒ์ด๋ค.O(1)var n = []; // n์ ๊ณ์์ ์ผ๋ก ์ซ์ ๋์
function o1() { return (n[0] === 0) ? true : false; } // ๋ฐ์ดํฐ๊ฐ ์ฆ๊ฐํด๋ ์ function o1 function์ ์ฑ๋ฅ์ ๊ทธ๋๋ก๋ค. O(n)let n = []; for (let i = 0; i < n.length; i++) { return n[i] } // ๋ฐฐ์ด์ n์ ๊ธธ์ด๊ฐ ์ฆ๊ฐํ ๋๋ง๋ค ์ฒ๋ฆฌ ์๊ฐ์ด ์ฆ๊ฐํ๋ค.์
๋ ฅn๋งํผ ์ถ๋ ฅ์ ๋ฐ๋ณตํ๋ ๋ฐ๋ณต๋ฌธ O(n^2)let n = []; for(let i = 0;..
ํด์์ ๊ฐ๋
ํด์๋ ํค:๋ฐธ๋ฆฌ์ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ฐ๋ ๋ฐฐ์ด ์ ํ๋ฒํธ๋ถ์ฒ๋ผ ๊ฒ์์ฐฝ์ ์ด๋ฆ(ํค)์ ๊ฒ์ -> ์ ํ๋ฒํธ(๋ฐธ๋ฅ)๊ฐ ๋์ด ํค๊ฐ ์คํธ๋ง์ด๋คํด์๋งต ํจ์HashMap.put("A", true); ๋ผ๊ณ ์
๋ ฅํ๋ฉด ๋ง์น HashMap["A"] = true;์๋ ํด์๋งตํจ์๋ a๊ฐ ์๋ค๋ ๊ฒ์ ์ ์ ๋ก ํ๊ธฐ ๋๋ฌธ์ a๊ฐ ์๋ค๋ฉด ์๋ฌ๊ฐ ๋ฐ์ํ๋ ์์
์ด ํ์. ๊ทธ๋์ a๊ฐ ์๋ค๋ ๊ฒ์ ํ์ธํด์ผ ํ๋ ๋ฒ๊ฑฐ๋ก์์ด ์๋๋ฐ ์ด๊ฑธ ๊ฐ์ ํ๊ธฐ ์ํ ๊ฒ์ด ๊ฒ์ฌ ํฐํดํธ ํจ์์ด๋ค ํค๊ฐ ์์ ๊ฒฝ์ฐ ์๋ฌ์ฒ๋ฆฌ๋ฅผ ํ ํจ์๋ด์์ ์ ๋ถํด์ฃผ๋ ๊ฒ. get/ put/ getOrDefaultString์ ๊ธฐ๋ฐ์ผ๋ก ์ ๋ณด๋ฅผ ๊ธฐํญํ๊ณ ๊ด๋ฆฌํด์ผ ๋ ๋ (์คํธ๋งํ์
์ ๊ธฐ์ค์ผ๋ก ์ ๋ณด๋ฅผ ๊ธฐ๋กํ๊ณ ๊ด๋ฆฌํ๋ ค๋ฉด ๋จ์๋ฐฐ์ด์ ์ธ ์ ์์ผ๋ ํด์๋ฅผ ์ฐ์) 1) ์์ฃผํ์ง ๋ชปํ ์ ์ ..
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..
ํ๋ก๊ทธ๋๋จธ์ค - ๋ชจ์์ฌ์ ๋ฌธ์ ์ค๋ช
์ฌ์ ์ ์ํ๋ฒณ ๋ชจ์ 'A', 'E', 'I', 'O', 'U'๋ง์ ์ฌ์ฉํ์ฌ ๋ง๋ค ์ ์๋, ๊ธธ์ด 5 ์ดํ์ ๋ชจ๋ ๋จ์ด๊ฐ ์๋ก๋์ด ์์ต๋๋ค. ์ฌ์ ์์ ์ฒซ ๋ฒ์งธ ๋จ์ด๋ "A"์ด๊ณ , ๊ทธ๋ค์์ "AA"์ด๋ฉฐ, ๋ง์ง๋ง ๋จ์ด๋ "UUUUU"์
๋๋ค. ๋จ์ด ํ๋ word๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ด ๋จ์ด๊ฐ ์ฌ์ ์์ ๋ช ๋ฒ์งธ ๋จ์ด์ธ์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ์ฌํญ word์ ๊ธธ์ด๋ 1 ์ด์ 5 ์ดํ์
๋๋ค. word๋ ์ํ๋ฒณ ๋๋ฌธ์ 'A', 'E', 'I', 'O', 'U'๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ์
์ถ๋ ฅ ์ ์
์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1 ์ฌ์ ์์ ์ฒซ ๋ฒ์งธ ๋จ์ด๋ "A"์ด๊ณ , ๊ทธ๋ค์์ "AA", "AAA", "AAAA", "AAAAA", "AAAAE",..
ํ๋ก๊ทธ๋๋จธ์ค - ๊ดํธ ๋ณํ ๋ฌธ์ ์ค๋ช
์นด์นด์ค์ ์ ์
๊ฐ๋ฐ์๋ก ์
์ฌํ "์ฝ"์ ์ ๋ฐฐ ๊ฐ๋ฐ์๋ก๋ถํฐ ๊ฐ๋ฐ์ญ๋ ๊ฐํ๋ฅผ ์ํด ๋ค๋ฅธ ๊ฐ๋ฐ์๊ฐ ์์ฑํ ์์ค ์ฝ๋๋ฅผ ๋ถ์ํ์ฌ ๋ฌธ์ ์ ์ ๋ฐ๊ฒฌํ๊ณ ์์ ํ๋ผ๋ ์
๋ฌด ๊ณผ์ ๋ฅผ ๋ฐ์์ต๋๋ค. ์์ค๋ฅผ ์ปดํ์ผํ์ฌ ๋ก๊ทธ๋ฅผ ๋ณด๋ ๋๋ถ๋ถ ์์ค ์ฝ๋ ๋ด ์์ฑ๋ ๊ดํธ๊ฐ ๊ฐ์๋ ๋ง์ง๋ง ์ง์ด ๋ง์ง ์์ ํํ๋ก ์์ฑ๋์ด ์ค๋ฅ๊ฐ ๋๋ ๊ฒ์ ์๊ฒ ๋์์ต๋๋ค. ์์ ํด์ผ ํ ์์ค ํ์ผ์ด ๋๋ฌด ๋ง์์ ๊ณ ๋ฏผํ๋ "์ฝ"์ ์์ค ์ฝ๋์ ์์ฑ๋ ๋ชจ๋ ๊ดํธ๋ฅผ ๋ฝ์์ ์ฌ๋ฐ๋ฅธ ์์๋๋ก ๋ฐฐ์น๋ ๊ดํธ ๋ฌธ์์ด์ ์๋ ค์ฃผ๋ ํ๋ก๊ทธ๋จ์ ๋ค์๊ณผ ๊ฐ์ด ๊ฐ๋ฐํ๋ ค๊ณ ํฉ๋๋ค. ์ฉ์ด์ ์ ์ '(' ์ ')' ๋ก๋ง ์ด๋ฃจ์ด์ง ๋ฌธ์์ด์ด ์์ ๊ฒฝ์ฐ, '(' ์ ๊ฐ์์ ')' ์ ๊ฐ์๊ฐ ๊ฐ๋ค๋ฉด ์ด๋ฅผ ๊ท ํ์กํ ๊ดํธ ๋ฌธ์์ด์ด๋ผ๊ณ ๋ถ๋ฆ
๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฌ๊ธฐ์ ..
ํ๋ก๊ทธ๋๋จธ์ค - ๊ตฌ๋ช
์กฐ๋ผ ๋ฌธ์ ์ค๋ช
๋ฌด์ธ๋์ ๊ฐํ ์ฌ๋๋ค์ ๊ตฌ๋ช
๋ณดํธ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌ์ถํ๋ ค๊ณ ํฉ๋๋ค. ๊ตฌ๋ช
๋ณดํธ๋ ์์์ ํ ๋ฒ์ ์ต๋ 2๋ช
์ฉ ๋ฐ์ ํ ์ ์๊ณ , ๋ฌด๊ฒ ์ ํ๋ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ์ฌ๋๋ค์ ๋ชธ๋ฌด๊ฒ๊ฐ [70kg, 50kg, 80kg, 50kg]์ด๊ณ ๊ตฌ๋ช
๋ณดํธ์ ๋ฌด๊ฒ ์ ํ์ด 100kg์ด๋ผ๋ฉด 2๋ฒ์งธ ์ฌ๋๊ณผ 4๋ฒ์งธ ์ฌ๋์ ๊ฐ์ด ํ ์ ์์ง๋ง 1๋ฒ์งธ ์ฌ๋๊ณผ 3๋ฒ์งธ ์ฌ๋์ ๋ฌด๊ฒ์ ํฉ์ 150kg์ด๋ฏ๋ก ๊ตฌ๋ช
๋ณดํธ์ ๋ฌด๊ฒ ์ ํ์ ์ด๊ณผํ์ฌ ๊ฐ์ด ํ ์ ์์ต๋๋ค. ๊ตฌ๋ช
๋ณดํธ๋ฅผ ์ต๋ํ ์ ๊ฒ ์ฌ์ฉํ์ฌ ๋ชจ๋ ์ฌ๋์ ๊ตฌ์ถํ๋ ค๊ณ ํฉ๋๋ค. ์ฌ๋๋ค์ ๋ชธ๋ฌด๊ฒ๋ฅผ ๋ด์ ๋ฐฐ์ด people๊ณผ ๊ตฌ๋ช
๋ณดํธ์ ๋ฌด๊ฒ ์ ํ limit๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋ชจ๋ ์ฌ๋์ ๊ตฌ์ถํ๊ธฐ ์ํด ํ์ํ ๊ตฌ๋ช
๋ณดํธ ๊ฐ์์ ์ต์๊ฐ์ return ํ๋๋ก solut..