ํ์ด๐๐ปโ๏ธ function solution(nums) { const numsSetSize = new Set(nums).size; const numsHalfCount = nums.length / 2; return numsSetSize > numsHalfCount ? numsHalfCount : numsSetSize; } /* (ํ์ด) ์ฃผ์ด์ง ๋ฐฐ์ด์ Set ๊ฐ์ฒด๋ก ๋ณํํ์ฌ ์ค๋ณต์ ์ ๊ฑฐํด์ฃผ๊ณ numsSetSize๊ฐ nums์ ๊ฐ์ / 2 ๋ณด๋ค ๋ง์ผ๋ฉด nums.length์ ์ ๋ฐ์ธ numsHalfCount๋ฅผ ๋ฆฌํดํด์ฃผ๊ณ ์๋๋ฉด numsSetSize๋ฅผ ๋ฆฌํดํด์ค๋ค. ์์งํ ๋ ํ๋ ์ผ์ด์ค๊ฐ ์๋ค๋๊ฐ ํด์ ์คํจํ ์ค ์์๋๋ฐ ํต๊ณผ๋๋ค. ํ
์คํธ์ ์ด๋ฆ์ ๋ณด๋ ํด์์ธ๋ฐ ๊ด๋ จ ์๋ฃ๋ฅผ ์ฐพ์๋ณด๋ ํด์๋ ์์์ ๊ธธ์ด์ ๋ฐ์ดํฐ๋ฅผ..
FE๋ฅผ ํฅํดโโ
ํ์ด ๐๐ปโ๏ธ function solution(sizes) { const maxSizes = Math.max(...sizes.flat()); let secondMaxSizes = 0; for (el of sizes) { if (el[0] > el[1]) { if (el[1] > secondMaxSizes) { secondMaxSizes = el[1]; } } else { if (el[0] > secondMaxSizes) { secondMaxSizes = el[0]; } } } return maxSizes * secondMaxSizes; } ๋ถํ์ํ if ๋ฌธ์ด ๋ง์๋ณด์ธ๋ค.. ํผ๋๋ฐฑ function solution(sizes) { const maxSize = Math.max(...sizes.flat());..
์คํ (stack) ์คํ์ ํ ์ชฝ ๋์์๋ง ์๋ฃ๋ฅผ ๋ฃ๊ฑฐ๋ ๋บ ์ ์๋ ์ ํ ๊ตฌ์กฐ(LIFO - Last In First Out)์ด๋ค. ๋งจ ์์ชฝ ์์ดํ
์ top์ด๋ผ ํ๋ค. ์๋ฃ๋ฅผ ๋ฃ๋๊ฒ์ push, ๋ฃ์ด๋ ์๋ฃ๋ฅผ ๊บผ๋ด๋ ๊ฒ์ pop์ด๋ผ ํ๋ค. pop์ ๊บผ๋ด์ง๋ ์๋ฃ๋ ๊ฐ์ฅ ์ต๊ทผ์ pushํ ์๋ฃ๋ถํฐ ๋์ค๊ฒ ๋๋ค. ๋ณดํต ์คํ์ ์๊ฐ ๋ซ๋ฆฐ ๋น์ปค ์ด๋ฏธ์ง๋ฅผ ์์ํ๋ฉด ํธํ๋ค. ์คํ์ด ๊ฝ์ฐจ๋ฉด Stack Overflow , ๋น์ด์๋ ์ํ๋ฅผ Underflow๋ผ ํ๋ค.
Learned Array.from์ ๋ํด ์กฐ๊ธ ๋ ์ดํดํ๋ค. ์ฌ๊ทํจ์์ ๋ํด ๋ฐฐ์ ๋ค. ์๋ฃ๊ตฌ์กฐ ์คํ / ํ์ ๋ํด ๋ฐฐ์ ๋ค. Liked ๊ตฌ๊ธ๋ง์ด ์๋ ๋ด ๋จธ๋ฆฌ๋ก ํ์ฃผ ๋ฌธ์ ๋ฅผ ๋ค ํ์๋ค. ์คํ/ํ์ ๋ํด ์ ๋ฆฌํ๋ฉฐ ์ดํด๋๊ฐ ์ฌ๋๋ค. Lacked ๋ณ์ ํค์๋ ์ค์. ๋ฌธ์ ํ์ด์ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด ๊ธธ๋ค. ํ ๊ฒ ๋ง์์ ์ ๋ฆฌ๋ฅผ ๋ฏธ๋ฃจ๊ฒ ๋๋ค.
ํ์ด ๐๐ปโ๏ธ function solution(s) { const strArr = s.split(" "); let result = ""; for (let i = 0; i < strArr.length; i++) { for (let j = 0; j < strArr[i].length; j++) { result += !(j % 2) ? strArr[i][j].toUpperCase() : strArr[i][j].toLowerCase(); } if (i < strArr.length - 1) { result += " "; } } return result; } /* (ํ์ด) ํ๋ ์ผ์ด์ค ํด๊ฒฐ์ ์ ๋ง ๋ง์ ์๊ฐ์ ๋ฒ๋ ธ๋ค.. 2์ค for๋ฌธ์ผ๋ก split์ผ๋ก ๋๋ ์ค strArr ๋ฐฐ์ด์์์ ๊ฐ์๋งํผ ๋๋ ค์ฃผ๊ณ ๋ด๋ถ for๋ฌธ์์..
ํ์ด ๐๐ปโ๏ธ function solution(arr) { return arr.filter((el, idx) => el !== arr[idx + 1]); } ํด๋น ๋ฌธ์ ๋ ์คํ/ํ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํด ํธ๋ ํ์ด์๋๋ฐ ํ์ด์์ฒด๋ ์ข์ง๋ง ๋ฌธ์ ์๋์ ๋ง์ง์๋ค. ์๋์ ๋ง๋ ํ์ด์ ๋ํด ์์๋ณด์. ๋ฌธ์ ์๋์ ๋ง๋ ํ์ด function solution(arr) { const result = []; for (const el of arr) { const lastElement = result[result.length - 1]; if (lastElement !== el) result.push(el); } return result; } ์คํฐ๋ ๋ฆฌ๋๋์ด ์ฌ๋ ค์ฃผ์ ํ์ด. ์คํ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง ํ์ด๋ค. ๋๋ ์์๋ฅผ ๋นผ๊ณ ๋ฃ๋ ์์
..
ํ (Queue) FIFO(First In First Out) ์ ๊ธฐ์ค์ผ๋ก ๋ง๋ค์ด์ง ์๋ฃ๊ตฌ์กฐ๋ค. ( ๋จผ์ ๋ค์ด์จ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ๋๊ฐ๋ค ) ๋ฐ์ดํฐ์ ์ฝ์
ํ๋ ๋ถ๋ถ์ rear ์ญ์ ํ๋ ๋ถ๋ถ์ fornt ๋ผ ๋ถ๋ฅธ๋ค. ํ์ ์ข
๋ฅ๋ ์ ํ ํ(Linear Queue), ์ํ ํ(Circular Queue) ๋ฑ์ด ์๋ค. ๋ฐ์ดํฐ๋ฅผ ์ง์ด๋ฃ๋ enqueue, ๋ฐ์ดํฐ๋ฅผ ์ถ์ถํ๋ dequeue ๋ฑ์ ์์
์ ํ ์ ์๋ค. ํ๋ ์์๋๋ก ์ฒ๋ฆฌํด์ผ ํ๋ ์์
์ ์์๋ก ์ ์ฅํด๋๋ ๋ฒํผ(buffer)๋ก ๋ง์ด ์ฌ์ฉํ๋ค. ์๋ฐ์คํฌ๋ฆฝํธ์์ push, shift๋ก ๊ตฌํ์ด ๊ฐ๋ฅํ๋ shift์ ์๊ฐ ๋ณต์ก๋๋ ์ต๋ O(n)์ด๋ ์ฃผ์ํ์. const arr = []; //enqueue arr.push('test1'); arr.push('test2..
ํ์ด ๐๐ปโ๏ธ function solution(n, m) { return [maxAcommonDivisor(n, m), (n * m) / maxAcommonDivisor(n, m)]; } function maxAcommonDivisor(a, b) { let remainder = 0; while (b !== 0) { remainder = a % b; a = b; b = remainder; } return a; } /* (ํ์ด) ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ ํจ์๋ฅผ ๋ง๋ค์ด์ค๋ค. ํจ์๋ ๋๋จธ์ง ๊ฐ์ ๋ฃ์ด์ฃผ๋ ๋ณ์ํ๋๋ฅผ ์์ฑํด์ฃผ๊ณ while ๋ฌธ์ผ๋ก b๊ฐ 0์ด ๋๋ฉด ํ์ถํ๊ฒ ๋๋๋ฐ ์ด์ ๋ (a๊ฐ ์์๊ฒฝ์ฐ) remainder = a ๊ฐ ๊ทธ๋๋ก ๋ค์ด๊ฐ a = b a๋ณด๋ค ํฐ๊ฐ์ธ b๊ฐ ๋ค์ด๊ฐ b = remainder ๋๋จธ์ง๊ฐ์ด ..