ํ์ด ๐๐ปโ๏ธ 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 ๋๋จธ์ง๊ฐ์ด ..
ํ์ด ๐๐ปโ๏ธ function solution(left, right) { let result = 0; const numArr = new Array(right - left + 1).fill().map((_, i) => left + i); for (let element of numArr) { let i = 1; const divisorArr = []; while (i
์ ํด๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ์ด๋? 2๊ฐ์ ์ ์ ๋๋ ๋ ๋คํญ์์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ด๋ค. ์๊ณ ๋ฆฌ์ฆ์ "A > B ์ผ๋ A์ B์ ์ต๋๊ณต์ฝ์๋ B์ ๋๋จธ์ง R์ ์ต๋๊ณต์ฝ์์ ๊ฐ๋ค." ํฐ ์(A)๋ฅผ ์์ ์(B)๋ก ๋๋๋ค. ( A > B ) ๋๋ ์(B)๋ฅผ A๋ก ๋์
๋๋จธ์ง(R)์ B๋ก ๋์
ํ์ฌ ๊ณ์ ๋๋ ์ค๋ค. ( A(B) % B(R) = (R)) ๋๋จธ์ง๊ฐ 0์ด ๋๋ค๋ฉด ์ด์ ์ B์ ๋์
ํ R์ด ์ต๋๊ณต์ฝ์์ด๋ค. ์์ 1071์ 1029๋ก ๋๋์ด ๋จ์ด์ง์ง ์๊ธฐ ๋๋ฌธ์, 1071์ 1029๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ค. โซ 42 1029๋ 42๋ก ๋๋์ด ๋จ์ด์ง์ง ์๊ธฐ ๋๋ฌธ์, 1029๋ฅผ 42๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ค. โซ 21 42๋ 21๋ก ๋๋์ด ๋จ์ด์ง๋ค. ๋ฐ๋ชฉ๋ฌธ const gcd =(a,b){ let tmp; while..
Learned map์ด๋ filter ๋ฑ ๋ฐ๋ณต๋ฌธ๊ณผ ๋น์ทํ ๋ฉ์๋๋ฅผ ์ด์ฉํ ๋ ๋ณ์๋ค์์ for๋ฌธ๊ณผ ๋์ผํ๊ฒ i, j ๋ก ๊ฐ์ ธ๊ฐ๊ธฐ. while๋ฌธ์ ์ข ๋ ๋ค์ํ ๋ฐฉ๋ฉด์ผ๋ก ์ฌ์ฉํ ์ ์๊ฒ๋๋ค. reduce์ Array์์ฑ์๋ฅผ ๋ค์ํ ๋ฐฉ๋ฒ์ผ๋ก ์ฌ์ฉํ ์ ์๊ฒ๋๋ค. Liked ํผ๋๋ฐฑ์ด ๋ฐ๋ก ์๋ ๋ฌธ์ ๊ฐ ๋ง์๋ค๐ ๊ฐ๋
์ฑ๋ฉด์์๋ ๋จ์ด์ก์ด๋ ๊ตฌ๊ธ๋ง ์ ํ ์์ด ํ์ด๋ธ ๋ฌธ์ ๋ ์์๋ค. Lacked ๋ช
ํํ ๋ณ์๋ช
์ง๊ธฐ๊ฐ ์์ง๋ ๋ถ์กฑํ๋ค. ๋ฌธ์ ํ์ด์ ๊ธ๊ธํด์ ์ผํญ์ฐ์ฐ์ ๋ฑ ๊ฐ๋
์ฑ ์ข์ ๋ฐฉ๋ฒ์ ๋ง์ด ๋์ณค๋ค.
ํ์ด ๐๐ปโ๏ธ function solution(arr1, arr2) { return arr1.map((v, i) => v.map((value, idx) => value + arr2[i][idx])); } /* (ํ์ด) ์์ ์ ํผ์ ํ์ด๋ดค๋ ๋ฌธ์ ๋ค. map ๋ฉ์๋๋ฅผ 2์ค์ผ๋ก ์ฌ์ฉํด 2์ค for๋ฌธ๊ณผ ๊ฐ์ ์ฉ๋๋ก ์ฌ์ฉํ๋๋ฐ ์ฒซ๋ฒ์งธ map์์ 1์ฐจ์ ๋ฐฐ์ด์ v๊ฐ์์ ํ๋ฒ ๋ map์ ์ฃผ๋ฉด 2์ฐจ์ ๋ฐฐ์ด๋ก ๋ค์ด๊ฐ๊ฒ๋๋ค. ๊ทธ๋ ๊ฒ ์ฃผ์ด์ง ๋ฐฐ์ด์ ์์ value์ arr2์ 2์ฐจ์๋ฐฐ์ด์ ์ฃผ์ด์ง index๊ฐ์ผ๋ก ๋ง์ถฐ ์ฃผ๋ฉด ๋. */ ํผ๋๋ฐฑ function solution(arr1, arr2) { return arr1.map((innerArr, i) => innerArr.map((value, j) => value + ar..