Algorithm/์ธํ๋ฐ(inflearn)
๐ 08 - ๋ชจ๋ ์๋๊ทธ๋จ ์ฐพ๊ธฐ(ํด์ฌ, ํฌํฌ์ธํฐ, ์ฌ๋ผ์ด๋ฉ ์๋์ฐ) S๋ฌธ์์ด์์ T๋ฌธ์์ด๊ณผ ์๋๊ทธ๋จ์ด ๋๋ S์ ๋ถ๋ถ๋ฌธ์์ด์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์์ด๋ค. ๋์ ํ์ด ๋ฐฉ๋ฒ ์๋๊ทธ๋จ์ด ๋๋์ง ํ์ธํ๊ธฐ ์ํด ํด์ฌ์ ํน์ง์ ์ฌ์ฉํ๊ณ , ๋ถ๋ถ ๋ฌธ์์ด์ ๊ตฌํ๊ธฐ ์ํด ์ฌ๋ผ์ด๋ฉ ์๋์ฐ ๋ฐฉ์๊ณผ slice() ํจ์๋ฅผ ์ฌ์ฉํ์๋ค. ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ณ ๋์ ์ ํ์๋ค๊ณ ์๊ฐํ์ง๋ง.. ์ฝ๋๋ฅผ ๋ค์ ๋ณด๋ ๋ถ๋ถ ๋ฌธ์์ด์ ๊ตฌํ๋ ๋ถ๋ถ์ ์์ด์ ์ด์ค for ๋ฌธ์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ํจ์จ์ฑ(์๊ฐ ๋ณต์ก๋) ์ธก๋ฉด์์๋ ์ข์ง ์๋ค๋ผ๊ณ ์๊ฐํ๋ค. for ๋ฌธ์ ๋๊ธฐ ์ ์ t์ ํด์ฌ ๊ฐ์ ๊ตฌํ๋ค. for ๋ฌธ์ ๋๋ฉด์ s๋ฌธ์์ด์ slice() ํจ์๋ฅผ ์ด์ฉํ์ฌ i ๋ฒ์งธ ์ธ๋ฑ์ค๋ถํฐ t๋ฌธ์์ด ๊ธธ์ด + i ์ ๊น์ง๋ฅผ ์๋ผ์ค ํ str ๋ณ์์ ์ ์ฅํ๋ค. (๋ถ๋ถ ๋ฌธ์์ด์ ..
Algorithm/์ธํ๋ฐ(inflearn)
๐ 04 - ์ฐ์ ๋ถ๋ถ์์ด 2(ํฌ ํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ) N๊ฐ์ ์๋ก ์ด๋ฃจ์ด์ง ์์ด์ด ์ฃผ์ด์ง๋ค. ์ด ์์ด์์ ์ฐ์๋ถ๋ถ์์ด์ ํฉ์ด ํน์ ์ซ์ M์ดํ๊ฐ ๋๋ ๊ฒฝ์ฐ๊ฐ ๋ช ๋ฒ ์๋์ง ์ถ๋ ฅํ๋ ๋ฌธ์ ์ด๋ค. ๋์ ํ์ด ๋ฐฉ๋ฒ for ๋ฌธ์ ์ฐจ๋ก๋๋ก ๋๋ฉฐ ํฌ์ธํฐ rt์ ์์น๋ฅผ ์ด๋์ํจ๋ค. ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ฐ์ sum์ ๋์ ์์ผ์ค๋ค. sum์ด m๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ answer++์ ํด์ค๋ค. ํฌ์ธํฐ rt๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ฐ์ด m ์ดํ์ด๊ณ sum๊ณผ ๊ฐ์ง ์๋ค๋ฉด answer++์ ํด์ค๋ค. ํฌ์ธํฐ rt๊ฐ 1์ฉ ์ฆ๊ฐํ ๋๋ง๋ค ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ฐ์ด ํน์ ์ซ์ M์ดํ๊ฐ ๋๋ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค. ์ ๊ณผ์ ์์ sum์ด m๋ณด๋ค ํฌ๊ณ ๊ฐ์์ง ๊ฒฝ์ฐ ํฌ์ธํฐ lt๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ฐ์ sum์์ ๋นผ์ค๋ค. sum์ด m ์ดํ์ด๊ณ ํฌ์ธํฐ..
Algorithm/์ธํ๋ฐ(inflearn)
๐ ๋ฌธ์ N๊ฐ์ ์๋ก ์ด๋ฃจ์ด์ง ์์ด์ด ์ฃผ์ด์ง๋ค. ์ด ์์ด์์ ์ฐ์ ๋ถ๋ถ ์์ด์ ํฉ์ด ํน์ ์ซ์ M์ด ๋๋ ๊ฒฝ์ฐ๊ฐ ๋ช ๋ฒ ์๋์ง ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค. ๋ง์ฝ N=8, M=6์ด๊ณ ์์ด์ด ๋ค์๊ณผ ๊ฐ๋ค๋ฉด 1 2 1 3 1 1 1 2 ํฉ์ด 6์ด ๋๋ ์ฐ์ ๋ถ๋ถ ์์ด์ {2, 1, 3}, {1, 3, 1, 1}, {3, 1, 1, 1}๋ก ์ด 3๊ฐ์ง์ด๋ค. ๐ ํ์ด ๐ง๐ป๐ป ๋์ ํ์ด ๋ฐฉ๋ฒ lt(์ผ์ชฝ์ ๋ด๋นํ ํฌ์ธํฐ), rt(์ค๋ฅธ์ชฝ์ ๋ด๋นํ ํฌ์ธํฐ)๋ฅผ ์ธ๋ฑ์ค 0์ผ๋ก ์ด๊ธฐํํ๋ค. rt ํฌ์ธํฐ๋ฅผ ํ์นธ์ฉ ์ด๋(์ฆ๊ฐ)์ํค๋ฉด์ ํฌ์ธํฐ์ ํด๋นํ๋ ๊ฐ์ sum์ ๋์ ์ํจ๋ค. ์ ๊ณผ์ ์์ sum์ด m๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด ๋ค์ ํ๊ฐ๋ฅผ ์ํด while๋ฌธ์ ๋๋ฉด์ lt ํฌ์ธํฐ์ ํด๋นํ๋ ๊ฐ์ sum์์ ๋นผ์ฃผ๊ณ ํ์นธ ์ด๋์์ผ์ผ ํ๋ค. ์ด์ ์ su..
Algorithm/์ธํ๋ฐ(inflearn)
๐ ๋ฌธ์ A, B ๋ ๊ฐ์ ์งํฉ์ด ์ฃผ์ด์ง๋ฉด ๋ ์งํฉ์ ๊ณตํต ์์๋ฅผ ์ถ์ถํ์ฌ ์ค๋ฆ์ฐจ์์ผ๋ก ์ถ๋ ฅํ๋ ๋ฌธ์ ์ด๋ค. ๐ ํ์ด ๐ง๐ป๐ป ๋์ ํ์ด ๋ฐฉ๋ฒ arr1์ sort() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค. arr1์ ํ๋์ฉ ๋๋ฉด์ includes() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ํด๋น ๊ฐ์ด arr2์ ์กด์ฌ(true)ํ๋ค๋ฉด answer์ ๊ฐ์ ์ฝ์
ํ๋ค. function solution(arr1, arr2) { const answer = []; arr1.sort((a, b) => a - b); for (let x of arr1) { if (arr2.includes(x)) answer.push(x); } return answer; } let a = [1, 3, 9, 5, 2]; let b = [3, 2, 5, 7, 8];..
Algorithm/์ธํ๋ฐ(inflearn)
๐ ๋ฌธ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ์ด ๋ ๋ ๋ฐฐ์ด์ด ์ฃผ์ด์ง๋ฉด ๋ ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ํฉ์ณ ์ถ๋ ฅํ๋ ๋ฌธ์ ์ด๋ค. ๐ ํ์ด ๐ง๐ป๐ป ๋์ ํ์ด ๋ฐฉ๋ฒ(๊ฐ์ฌ๋ ํ์ด ๋ฐฉ๋ฒ๊ณผ ๋์ผ๐) ๋ ๋ฐฐ์ด์ ํ๋๋ก([...arr1, ...arr2]) ํฉ์น๊ณ sort() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ ๋ ฌํจ์ผ๋ก์จ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์๋ ์์ง๋ง, sort() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ ๊ฒฝ์ฐ ๋ธ๋ผ์ฐ์ ์์ง๋ง๋ค ๋ค๋ฅด์ง๋ง ํ๊ท ์ ์ผ๋ก ์๊ฐ๋ณต์ก๋๊ฐ O(nlogn)์ ํด๋นํ๋ค. ์ด์ ๋นํด ํฌ ํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ฉด ์๊ฐ๋ณต์ก๋๋ O(n + m)์ด๋ฏ๋ก ๋งค์ฐ ํจ์จ์ ์ด๋ค. ํฌ์ธํฐ p1, p2๊ฐ ๊ฐ ๋ฐฐ์ด์ ๊ธธ์ด๋ณด๋ค ์์ ๊ฒฝ์ฐ while๋ฌธ์ ๋๋ฉฐ arr1[p1]๊ณผ arr2[p2]๋ฅผ ๋น๊ตํ๋ค. ์ค๋ฆ์ฐจ์์ผ๋ก ํฉ์ณ์ผ ํ๋ฏ๋ก ๋ ์์ ๊ฐ์ answer์ push() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ฝ์
ํ..