์๊ณ ๋ฆฌ์ฆ35 [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์ผ์ด์ฌ ์ผ์ด์ฌ ํ๊ตญ์คํ๊ต์ ๋ค๋๋ ํ์๋ค์ ๊ฐ์ ์ ์ ๋ฒํธ๋ฅผ ๊ฐ๊ณ ์์ต๋๋ค. ์ด ํ๊ต ํ์ 3๋ช ์ ์ ์ ๋ฒํธ๋ฅผ ๋ํ์ ๋ 0์ด ๋๋ฉด 3๋ช ์ ํ์์ ์ผ์ด์ฌ๋ผ๊ณ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, 5๋ช ์ ํ์์ด ์๊ณ , ๊ฐ๊ฐ์ ์ ์ ๋ฒํธ๊ฐ ์์๋๋ก -2, 3, 0, 2, -5์ผ ๋, ์ฒซ ๋ฒ์งธ, ์ธ ๋ฒ์งธ, ๋ค ๋ฒ์งธ ํ์์ ์ ์ ๋ฒํธ๋ฅผ ๋ํ๋ฉด 0์ด๋ฏ๋ก ์ธ ํ์์ ์ผ์ด์ฌ์ ๋๋ค. ๋ํ, ๋ ๋ฒ์งธ, ๋ค ๋ฒ์งธ, ๋ค์ฏ ๋ฒ์งธ ํ์์ ์ ์ ๋ฒํธ๋ฅผ ๋ํด๋ 0์ด๋ฏ๋ก ์ธ ํ์๋ ์ผ์ด์ฌ์ ๋๋ค. ๋ฐ๋ผ์ ์ด ๊ฒฝ์ฐ ํ๊ตญ์คํ๊ต์์๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ์ผ์ด์ฌ๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค. ํ๊ตญ์คํ๊ต ํ์๋ค์ ๋ฒํธ๋ฅผ ๋ํ๋ด๋ ์ ์ ๋ฐฐ์ด number๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ํ์๋ค ์ค ์ผ์ด์ฌ๋ฅผ ๋ง๋ค ์ ์๋ ๋ฐฉ๋ฒ์ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์... 2022. 12. 1. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : 2016๋ 2016๋ 2016๋ 1์ 1์ผ์ ๊ธ์์ผ์ ๋๋ค. 2016๋ a์ b์ผ์ ๋ฌด์จ ์์ผ์ผ๊น์? ๋ ์ a ,b๋ฅผ ์ ๋ ฅ๋ฐ์ 2016๋ a์ b์ผ์ด ๋ฌด์จ ์์ผ์ธ์ง ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์์ผ์ ์ด๋ฆ์ ์ผ์์ผ๋ถํฐ ํ ์์ผ๊น์ง ๊ฐ๊ฐ SUN,MON,TUE,WED,THU,FRI,SAT ์ ๋๋ค. ์๋ฅผ ๋ค์ด a=5, b=24๋ผ๋ฉด 5์ 24์ผ์ ํ์์ผ์ด๋ฏ๋ก ๋ฌธ์์ด "TUE"๋ฅผ ๋ฐํํ์ธ์. ์ ํ ์กฐ๊ฑด * 2016๋ ์ ์ค๋ ์ ๋๋ค. * 2016๋ a์ b์ผ์ ์ค์ ๋ก ์๋ ๋ ์ ๋๋ค. (13์ 26์ผ์ด๋ 2์ 45์ผ๊ฐ์ ๋ ์ง๋ ์ฃผ์ด์ง์ง ์์ต๋๋ค) ์ ์ถ๋ ฅ ์ a b result 5 24 "TUE" ๋ฌธ์ ํ์ด ์์ผ์ ๊ตฌํ๋ new Date ๊ดํธ ์์ 2016๋ 5์ 24์ผ์ ๋ฐธ๋ฅ๊ฐ์ผ๋ก ๋ฃ๊ณ ๊ทธ๊ฑธ toString์ผ๋ก .. 2022. 11. 30. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๋ฌธ์์ด ๋ด ๋ง์๋๋ก ์ ๋ ฌํ๊ธฐ ๋ฌธ์์ด ๋ด ๋ง์๋๋ก ์ ๋ ฌํ๊ธฐ ๋ฌธ์์ด๋ก ๊ตฌ์ฑ๋ ๋ฆฌ์คํธ strings์, ์ ์ n์ด ์ฃผ์ด์ก์ ๋, ๊ฐ ๋ฌธ์์ด์ ์ธ๋ฑ์ค n๋ฒ์งธ ๊ธ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋ ค ํฉ๋๋ค. ์๋ฅผ ๋ค์ด strings๊ฐ ["sun", "bed", "car"]์ด๊ณ n์ด 1์ด๋ฉด ๊ฐ ๋จ์ด์ ์ธ๋ฑ์ค 1์ ๋ฌธ์ "u", "e", "a"๋ก strings๋ฅผ ์ ๋ ฌํฉ๋๋ค. ์ ํ ์กฐ๊ฑด * strings๋ ๊ธธ์ด 1 ์ด์, 50์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค. * strings์ ์์๋ ์๋ฌธ์ ์ํ๋ฒณ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. * strings์ ์์๋ ๊ธธ์ด 1 ์ด์, 100์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค. * ๋ชจ๋ strings์ ์์์ ๊ธธ์ด๋ n๋ณด๋ค ํฝ๋๋ค. * ์ธ๋ฑ์ค 1์ ๋ฌธ์๊ฐ ๊ฐ์ ๋ฌธ์์ด์ด ์ฌ๋ฟ ์ผ ๊ฒฝ์ฐ, ์ฌ์ ์์ผ๋ก ์์ ๋ฌธ์์ด์ด ์์ชฝ์ ์์นํฉ๋๋ค. ์ ์ถ๋ ฅ ์ ์ ์ถ๋ ฅ ์ 1.. 2022. 11. 29. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์์ ์ํธ ์์ ์ํธ ์ด๋ค ๋ฌธ์ฅ์ ๊ฐ ์ํ๋ฒณ์ ์ผ์ ํ ๊ฑฐ๋ฆฌ๋งํผ ๋ฐ์ด์ ๋ค๋ฅธ ์ํ๋ฒณ์ผ๋ก ๋ฐ๊พธ๋ ์ํธํ ๋ฐฉ์์ ์์ ์ํธ๋ผ๊ณ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด "AB"๋ 1๋งํผ ๋ฐ๋ฉด "BC"๊ฐ ๋๊ณ , 3๋งํผ ๋ฐ๋ฉด "DE"๊ฐ ๋ฉ๋๋ค. "z"๋ 1๋งํผ ๋ฐ๋ฉด "a"๊ฐ ๋ฉ๋๋ค. ๋ฌธ์์ด s์ ๊ฑฐ๋ฆฌ n์ ์ ๋ ฅ๋ฐ์ s๋ฅผ n๋งํผ ๋ฏผ ์ํธ๋ฌธ์ ๋ง๋๋ ํจ์, solution์ ์์ฑํด ๋ณด์ธ์. ์ ํ ์กฐ๊ฑด * ๊ณต๋ฐฑ์ ์๋ฌด๋ฆฌ ๋ฐ์ด๋ ๊ณต๋ฐฑ์ ๋๋ค. s๋ ์ํ๋ฒณ ์๋ฌธ์, ๋๋ฌธ์, ๊ณต๋ฐฑ์ผ๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. s์ ๊ธธ์ด๋ 8000์ดํ์ ๋๋ค. n์ 1 ์ด์, 25์ดํ์ธ ์์ฐ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ s n result "AB" 1 "BC" "z" 1 "a" "a B z" 4 "e F d" ๋ฌธ์ ํ์ด var upper์๋ ๋๋ฌธ์๋ฅผ, var lower์๋ ์๋ฌธ์๋ฅผ ์ ์ฅ์.. 2022. 11. 28. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์์ฐ ์์ฐ S์ฌ์์๋ ๊ฐ ๋ถ์์ ํ์ํ ๋ฌผํ์ ์ง์ํด ์ฃผ๊ธฐ ์ํด ๋ถ์๋ณ๋ก ๋ฌผํ์ ๊ตฌ๋งคํ๋๋ฐ ํ์ํ ๊ธ์ก์ ์กฐ์ฌํ์ต๋๋ค. ๊ทธ๋ฌ๋, ์ ์ฒด ์์ฐ์ด ์ ํด์ ธ ์๊ธฐ ๋๋ฌธ์ ๋ชจ๋ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด ์ค ์๋ ์์ต๋๋ค. ๊ทธ๋์ ์ต๋ํ ๋ง์ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด ์ค ์ ์๋๋ก ํ๋ ค๊ณ ํฉ๋๋ค. ๋ฌผํ์ ๊ตฌ๋งคํด ์ค ๋๋ ๊ฐ ๋ถ์๊ฐ ์ ์ฒญํ ๊ธ์ก๋งํผ์ ๋ชจ๋ ์ง์ํด ์ค์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด 1,000์์ ์ ์ฒญํ ๋ถ์์๋ ์ ํํ 1,000์์ ์ง์ํด์ผ ํ๋ฉฐ, 1,000์๋ณด๋ค ์ ์ ๊ธ์ก์ ์ง์ํด ์ค ์๋ ์์ต๋๋ค. ๋ถ์๋ณ๋ก ์ ์ฒญํ ๊ธ์ก์ด ๋ค์ด์๋ ๋ฐฐ์ด d์ ์์ฐ budget์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ต๋ ๋ช ๊ฐ์ ๋ถ์์ ๋ฌผํ์ ์ง์ํ ์ ์๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด * d๋ ๋ถ์๋ณ๋ก ์ ์ฒญํ .. 2022. 11. 28. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : 3์ง๋ฒ ๋ค์ง๊ธฐ 3์ง๋ฒ ๋ค์ง๊ธฐ ์์ฐ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. n์ 3์ง๋ฒ ์์์ ์๋ค๋ก ๋ค์ง์ ํ, ์ด๋ฅผ ๋ค์ 10์ง๋ฒ์ผ๋ก ํํํ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด * n์ 1 ์ด์ 100,000,000 ์ดํ์ธ ์์ฐ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ n result 45 7 125 229 ๋ฌธ์ ํ์ด n์ toString(3)์ผ๋ก ๋ฌธ์์ด 3์ง๋ฒ์ผ๋ก ๋ง๋ ๋ค์ split('')์ ํตํด ์ชผ๊ฐ๊ณ ๋ฐฐ์ด๋ก ๋ง๋ ๋ค์ reverse๋ก ๋ด๋ฆผ์ฐจ์ ๋ฐฐ์น๋ฅผ ์ํจ ํ join์ผ๋ก ๋ค์ ๋ฌธ์์ด๋ก ํฉ์ณ์ค๋ค. ๋ง์ง๋ง์ผ๋ก parseInt(answer,3)์ ํตํด 3์ง์๋ก ๋ ๊ฐ์ 10์ง๋ฒ ์ ์ ๊ฐ์ผ๋ก ๋ณํ์ํฌ ์ ์๋ค. function solution(n) { let answer = n.toString(3).split.. 2022. 11. 28. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : K๋ฒ์งธ์ K๋ฒ์งธ์ ๋ฐฐ์ด array์ i๋ฒ์งธ ์ซ์๋ถํฐ j๋ฒ์งธ ์ซ์๊น์ง ์๋ฅด๊ณ ์ ๋ ฌํ์ ๋, k๋ฒ์งธ์ ์๋ ์๋ฅผ ๊ตฌํ๋ ค ํฉ๋๋ค. ์๋ฅผ ๋ค์ด array๊ฐ [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3์ด๋ผ๋ฉด 1. rray์ 2๋ฒ์งธ๋ถํฐ 5๋ฒ์งธ๊น์ง ์๋ฅด๋ฉด [5, 2, 6, 3]์ ๋๋ค. 2. 1์์ ๋์จ ๋ฐฐ์ด์ ์ ๋ ฌํ๋ฉด [2, 3, 5, 6]์ ๋๋ค. 3. 2์์ ๋์จ ๋ฐฐ์ด์ 3๋ฒ์งธ ์ซ์๋ 5์ ๋๋ค. ๋ฐฐ์ด array, [i, j, k]๋ฅผ ์์๋ก ๊ฐ์ง 2์ฐจ์ ๋ฐฐ์ด commands๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, commands์ ๋ชจ๋ ์์์ ๋ํด ์์ ์ค๋ช ํ ์ฐ์ฐ์ ์ ์ฉํ์ ๋ ๋์จ ๊ฒฐ๊ณผ๋ฅผ ๋ฐฐ์ด์ ๋ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์กฐ๊ฑด * array์ ๊ธธ์ด๋ 1 ์ด์ 100 ์ด.. 2022. 11. 25. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์ฝ์์ ๊ฐ์์ ๋ง์ ์ฝ์์ ๊ฐ์์ ๋ง์ ๋ ์ ์ left์ right๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. left๋ถํฐ right๊น์ง์ ๋ชจ๋ ์๋ค ์ค์์, ์ฝ์์ ๊ฐ์๊ฐ ์ง์์ธ ์๋ ๋ํ๊ณ , ์ฝ์์ ๊ฐ์๊ฐ ํ์์ธ ์๋ ๋บ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์กฐ๊ฑด โ 1 ≤ left ≤ right ≤ 1,000 ๋ฌธ์ ํ์ด count ๋ ์ฝ์๋ฅผ ๊ฐ์ง๊ณ ์๋ ์๋ค์ ํฉ ๋๋ ์ฐจ๋ฅผ ๊ตฌํ ๊ฐ. arr.length % 2 === 0 ? count += i : count -= i ์์ ํตํด ์ฝ์์ ๊ธธ์ด๊ฐ ํ์์ผ ๋ ์ง์์ผ ๋์ ๋ฐ๋ผ ๋ํด์ค ๊ฒ์ธ์ง ๋นผ์ค ๊ฒ์ธ์ง๋ฅผ ๊ฒฐ์ ํจ. function solution(left, right) { let count = 0; for(let i = left; i 2022. 11. 25. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์์ ๋ํ๊ธฐ ์์ ๋ํ๊ธฐ ์ด๋ค ์ ์๋ค์ด ์์ต๋๋ค. ์ด ์ ์๋ค์ ์ ๋๊ฐ์ ์ฐจ๋ก๋๋ก ๋ด์ ์ ์ ๋ฐฐ์ด absolutes์ ์ด ์ ์๋ค์ ๋ถํธ๋ฅผ ์ฐจ๋ก๋๋ก ๋ด์ ๋ถ๋ฆฌ์ธ ๋ฐฐ์ด signs๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ค์ ์ ์๋ค์ ํฉ์ ๊ตฌํ์ฌ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด * absolutes์ ๊ธธ์ด๋ 1 ์ด์ 1,000 ์ดํ์ ๋๋ค. * absolutes์ ๋ชจ๋ ์๋ ๊ฐ๊ฐ 1 ์ด์ 1,000 ์ดํ์ ๋๋ค. * signs์ ๊ธธ์ด๋ absolutes์ ๊ธธ์ด์ ๊ฐ์ต๋๋ค. * signs[i] ๊ฐ ์ฐธ์ด๋ฉด absolutes[i] ์ ์ค์ ์ ์๊ฐ ์์์์, ๊ทธ๋ ์ง ์์ผ๋ฉด ์์์์ ์๋ฏธํฉ๋๋ค. ์ ์ถ๋ ฅ ์ absolutes signs result [4,7,12] [true,false,true] 9 [1,2,3] [.. 2022. 11. 22. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๋ฌธ์์ด ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๊ธฐ ๋ฌธ์์ด ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๊ธฐ ๋ฌธ์์ด s์ ๋ํ๋๋ ๋ฌธ์๋ฅผ ํฐ๊ฒ๋ถํฐ ์์ ์์ผ๋ก ์ ๋ ฌํด ์๋ก์ด ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. s๋ ์๋ฌธ ๋์๋ฌธ์๋ก๋ง ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ, ๋๋ฌธ์๋ ์๋ฌธ์๋ณด๋ค ์์ ๊ฒ์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค. ์ ํ ์กฐ๊ฑด * str์ ๊ธธ์ด 1 ์ด์์ธ ๋ฌธ์์ด์ ๋๋ค. ์ ์ถ๋ ฅ ์ s return "Zbcdefg" "gfedcbZ" ๋ฌธ์ ํ์ด split('')์ผ๋ก s์ ๋ฌธ์์ด์ ๋ค ์ชผ๊ฐ๊ณ reverse๋ก ์์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๋ค. ๊ทธ๋ฐ ๋ค์, concat์ผ๋ก ์ชผ๊ฐ์ง ๋ฌธ์์ด๋ค์ ํฉ์น๋ค. toString์ผ๋ก ๋ฐฐ์ด ํํ์์ ๋ฌธ์์ด๋ก ๋ฐ๊พธ๊ณ ๋ง์ง๋ง์ผ๋ก replaceAll(',', '')์ ํตํด ์ผํ๋ฅผ ์ ๊ฑฐํด์ค๋ค. function solution(s) { var answer = ''; ans.. 2022. 11. 21. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์ ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์ ๋ ์๋ฅผ ์ ๋ ฅ๋ฐ์ ๋ ์์ ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด ๋ณด์ธ์. ๋ฐฐ์ด์ ๋งจ ์์ ์ต๋๊ณต์ฝ์, ๊ทธ๋ค์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๋ฃ์ด ๋ฐํํ๋ฉด ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ ์ 3, 12์ ์ต๋๊ณต์ฝ์๋ 3, ์ต์๊ณต๋ฐฐ์๋ 12์ด๋ฏ๋ก solution(3, 12)๋ [3, 12]๋ฅผ ๋ฐํํด์ผ ํฉ๋๋ค. ์ ํ ์กฐ๊ฑด * ๋ ์๋ 1์ด์ 1000000์ดํ์ ์์ฐ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ ์ ์ถ๋ ฅ ์ #1 * ์์ ์ค๋ช ๊ณผ ๊ฐ์ต๋๋ค. ์ ์ถ๋ ฅ ์ #2 * ์์ฐ์ 2์ 5์ ์ต๋๊ณต์ฝ์๋ 1, ์ต์๊ณต๋ฐฐ์๋ 10์ด๋ฏ๋ก [1, 10]์ ๋ฆฌํดํด์ผ ํฉ๋๋ค. n m result 3 12 [3,12] 2 5 [1,10] ๋ฌธ์ ํ์ด const min์ Math.min์ผ๋ก n,m์ ์ต์๊ฐ์ ์ ์ฅ, for๋ฌธ๊ณผ i.. 2022. 11. 21. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๋ด์ (ๅ ง็ฉ, inner product) ๋ด์ (ๅ ง็ฉ, inner product) ๊ธธ์ด๊ฐ ๊ฐ์ ๋ 1์ฐจ์ ์ ์ ๋ฐฐ์ด a, b๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. a์ b์ ๋ด์ ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ด๋, a์ b์ ๋ด์ ์ a[0]*b[0] + a[1]*b[1] + ... + a[n-1]*b[n-1] ์ ๋๋ค. (n์ a, b์ ๊ธธ์ด) ์ ํ ์กฐ๊ฑด * a, b์ ๊ธธ์ด๋ 1 ์ด์ 1,000 ์ดํ์ ๋๋ค. * a, b์ ๋ชจ๋ ์๋ -1,000 ์ด์ 1,000 ์ดํ์ ๋๋ค. ์ ์ถ๋ ฅ ์ ์ ์ถ๋ ฅ ์ #1 * a์ b์ ๋ด์ ์ 1*(-3) + 2*(-1) + 3*0 + 4*2 = 3 ์ ๋๋ค. ์ ์ถ๋ ฅ ์ #2 * a์ b์ ๋ด์ ์ (-1)*1 + 0*0 + 1*(-1) = -2 ์ ๋๋ค. a b result [1,2,3,4] [-3,-1,0.. 2022. 11. 21. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : 3์ง๋ฒ ๋ค์ง๊ธฐ 3์ง๋ฒ ๋ค์ง๊ธฐ ์์ฐ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. n์ 3์ง๋ฒ ์์์ ์๋ค๋ก ๋ค์ง์ ํ, ์ด๋ฅผ ๋ค์ 10์ง๋ฒ์ผ๋ก ํํํ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด * n์ 1 ์ด์ 100,000,000 ์ดํ์ธ ์์ฐ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ n result 45 7 125 229 ์ ์ถ๋ ฅ ์ #1 n(10์ง๋ฒ) n(3์ง๋ฒ) ์๋ค ๋ฐ์ (3์ง๋ฒ) 10์ง๋ฒ์ผ๋ก ํํ 45 1200 0021 7 * ๋ฐ๋ผ์ 7์ return ํด์ผ ํฉ๋๋ค. ์ ์ถ๋ ฅ ์ #2 n(10์ง๋ฒ) n(3์ง๋ฒ) ์๋ค ๋ฐ์ (3์ง๋ฒ) 10์ง๋ฒ์ผ๋ก ํํ 125 11122 22111 229 * ๋ฐ๋ผ์ 229๋ฅผ return ํด์ผ ํฉ๋๋ค. ๋ฌธ์ ํ์ด n์ด 0์ด ์๋ ๊ฒฝ์ฐ unshift๋ฅผ ํตํด n์ 3์ผ๋ก ๋๋ ๋๋จธ์ง๊ฐ์ answer์.. 2022. 11. 18. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์ด์ํ ๋ฌธ์ ๋ง๋ค๊ธฐ ์ด์ํ ๋ฌธ์ ๋ง๋ค๊ธฐ ๋ฌธ์์ด s๋ ํ ๊ฐ ์ด์์ ๋จ์ด๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. ๊ฐ ๋จ์ด๋ ํ๋ ์ด์์ ๊ณต๋ฐฑ๋ฌธ์๋ก ๊ตฌ๋ถ๋์ด ์์ต๋๋ค. ๊ฐ ๋จ์ด์ ์ง์๋ฒ์งธ ์ํ๋ฒณ์ ๋๋ฌธ์๋ก, ํ์๋ฒ์งธ ์ํ๋ฒณ์ ์๋ฌธ์๋ก ๋ฐ๊พผ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์ ํ ์กฐ๊ฑด * ๋ฌธ์์ด ์ ์ฒด์ ์ง/ํ์ ์ธ๋ฑ์ค๊ฐ ์๋๋ผ, ๋จ์ด(๊ณต๋ฐฑ์ ๊ธฐ์ค)๋ณ๋ก ์ง/ํ์ ์ธ๋ฑ์ค๋ฅผ ํ๋จํด์ผํฉ๋๋ค. * ์ฒซ ๋ฒ์งธ ๊ธ์๋ 0๋ฒ์งธ ์ธ๋ฑ์ค๋ก ๋ณด์ ์ง์๋ฒ์งธ ์ํ๋ฒณ์ผ๋ก ์ฒ๋ฆฌํด์ผ ํฉ๋๋ค. ์ ์ถ๋ ฅ ์ "try hello world"๋ ์ธ ๋จ์ด "try", "hello", "world"๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. ๊ฐ ๋จ์ด์ ์ง์๋ฒ์งธ ๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก, ํ์๋ฒ์งธ ๋ฌธ์๋ฅผ ์๋ฌธ์๋ก ๋ฐ๊พธ๋ฉด "TrY", "HeLlO", "WoRlD"์ ๋๋ค. ๋ฐ๋ผ์ "TrY HeLlO W.. 2022. 11. 17. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ํ์ค๋ ์ ํ์ค๋ ์ ์์ ์ ์ x๊ฐ ํ์ค๋ ์์ด๋ ค๋ฉด x์ ์๋ฆฟ์์ ํฉ์ผ๋ก x๊ฐ ๋๋์ด์ ธ์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด 18์ ์๋ฆฟ์ ํฉ์ 1+8=9์ด๊ณ , 18์ 9๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 18์ ํ์ค๋ ์์ ๋๋ค. ์์ฐ์ x๋ฅผ ์ ๋ ฅ๋ฐ์ x๊ฐ ํ์ค๋ ์์ธ์ง ์๋์ง ๊ฒ์ฌํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด * x๋ 1 ์ด์, 10000 ์ดํ์ธ ์ ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ ์ ์ถ๋ ฅ ์ #1 10์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 1์ ๋๋ค. 10์ 1๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 10์ ํ์ค๋ ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ #2 12์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 3์ ๋๋ค. 12๋ 3์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 12๋ ํ์ค๋ ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ #3 11์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 2์ ๋๋ค. 11์ 2๋ก ๋๋์ด ๋จ์ด์ง์ง ์์ผ๋ฏ๋ก 11๋ ํ์ค๋ ์๊ฐ ์๋๋๋ค. ์ ์ถ๋ ฅ ์ .. 2022. 11. 16. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ํ๋ ฌ์ ๋ง์ ํ๋ ฌ์ ๋ง์ ํ๋ ฌ์ ๋ง์ ์ ํ๊ณผ ์ด์ ํฌ๊ธฐ๊ฐ ๊ฐ์ ๋ ํ๋ ฌ์ ๊ฐ์ ํ, ๊ฐ์ ์ด์ ๊ฐ์ ์๋ก ๋ํ ๊ฒฐ๊ณผ๊ฐ ๋ฉ๋๋ค. 2๊ฐ์ ํ๋ ฌ arr1๊ณผ arr2๋ฅผ ์ ๋ ฅ๋ฐ์, ํ๋ ฌ ๋ง์ ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด * ํ๋ ฌ arr1, arr2์ ํ๊ณผ ์ด์ ๊ธธ์ด๋ 500์ ๋์ง ์์ต๋๋ค. ์ ์ถ๋ ฅ ์ arr1 arr2 return [[1,2],[2,3]] [[3,4],[5,6]] [[4,6],[7,9]] [[1],[2]] [[3],[4]] [[4],[6]] ๋ฌธ์ ํ์ด ์ค์ฒฉ for๋ฌธ์ ํตํด์ ํ๊ณผ ์ด์ ํฌ๊ธฐ๊ฐ ๊ฐ์ ๋ ํ๋ ฌ์ ๊ฐ์ ๋ํ ์ ์๋ค. function solution(arr1, arr2) { var answer = [[]]; for (let i=0; i < arr1.lengt.. 2022. 11. 16. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์ฝ๋ผ์ธ ์ถ์ธก ์ฝ๋ผ์ธ ์ถ์ธก 1937๋ Collatz๋ ์ฌ๋์ ์ํด ์ ๊ธฐ๋ ์ด ์ถ์ธก์, ์ฃผ์ด์ง ์๊ฐ 1์ด ๋ ๋๊น์ง ๋ค์ ์์ ์ ๋ฐ๋ณตํ๋ฉด, ๋ชจ๋ ์๋ฅผ 1๋ก ๋ง๋ค ์ ์๋ค๋ ์ถ์ธก์ ๋๋ค. ์์ ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. 1-1. ์ ๋ ฅ๋ ์๊ฐ ์ง์๋ผ๋ฉด 2๋ก ๋๋๋๋ค. 1-2. ์ ๋ ฅ๋ ์๊ฐ ํ์๋ผ๋ฉด 3์ ๊ณฑํ๊ณ 1์ ๋ํฉ๋๋ค. 2. ๊ฒฐ๊ณผ๋ก ๋์จ ์์ ๊ฐ์ ์์ ์ 1์ด ๋ ๋๊น์ง ๋ฐ๋ณตํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์ฃผ์ด์ง ์๊ฐ 6์ด๋ผ๋ฉด 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 ์ด ๋์ด ์ด 8๋ฒ ๋ง์ 1์ด ๋ฉ๋๋ค. ์ ์์ ์ ๋ช ๋ฒ์ด๋ ๋ฐ๋ณตํด์ผ ํ๋์ง ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด ์ฃผ์ธ์. ๋จ, ์ฃผ์ด์ง ์๊ฐ 1์ธ ๊ฒฝ์ฐ์๋ 0์, ์์ ์ 500๋ฒ ๋ฐ๋ณตํ ๋๊น์ง 1์ด ๋์ง ์๋๋ค๋ฉด –1์ ๋ฐํํด ์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด *.. 2022. 11. 15. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์ง์ฌ๊ฐํ ๋ณ์ฐ๊ธฐ ์ง์ฌ๊ฐํ ๋ณ์ฐ๊ธฐ ์ด ๋ฌธ์ ์๋ ํ์ค ์ ๋ ฅ์ผ๋ก ๋ ๊ฐ์ ์ ์ n๊ณผ m์ด ์ฃผ์ด์ง๋๋ค. ๋ณ(*) ๋ฌธ์๋ฅผ ์ด์ฉํด ๊ฐ๋ก์ ๊ธธ์ด๊ฐ n, ์ธ๋ก์ ๊ธธ์ด๊ฐ m์ธ ์ง์ฌ๊ฐํ ํํ๋ฅผ ์ถ๋ ฅํด๋ณด์ธ์. ์ ํ ์กฐ๊ฑด โ n๊ณผ m์ ๊ฐ๊ฐ 1000 ์ดํ์ธ ์์ฐ์์ ๋๋ค. ์์ ์ ๋ ฅ : 5 3 ์ถ๋ ฅ : ***** ***** ***** ๋ฌธ์ ํ์ด const n์๋ data.split(" ")์ ํตํด ๊ณต๋ฐฑ 1์นธ๋ง๋ค ์ชผ๊ฐ๋๋ก ํด๋๊ณ const a์๋ Number(n[0]), b์๋ Number(n[1])์ ์ ์ฅ์ํค๊ณ , ๋ง์ง๋ง์ผ๋ก const star์๋ '*'์ ๋ฐ๋ณต์ํค๋๋ก ์คํฌ๋ฆฝํธ๋ฅผ ์ง ๋ค. process.stdin.setEncoding('utf8'); process.stdin.on('data', data => { const n = data.spli.. 2022. 11. 15. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๋ฌธ์์ด ๋ค๋ฃจ๊ธฐ ๊ธฐ๋ณธ ๋ฌธ์์ด ๋ค๋ฃจ๊ธฐ ๊ธฐ๋ณธ ๋ฌธ์์ด s์ ๊ธธ์ด๊ฐ 4 ํน์ 6์ด๊ณ , ์ซ์๋ก๋ง ๊ตฌ์ฑ๋ผ์๋์ง ํ์ธํด์ฃผ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์๋ฅผ ๋ค์ด s๊ฐ "a234"์ด๋ฉด False๋ฅผ ๋ฆฌํดํ๊ณ "1234"๋ผ๋ฉด True๋ฅผ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค. ์ ํ ์กฐ๊ฑด โ s๋ ๊ธธ์ด 1 ์ด์, ๊ธธ์ด 8 ์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค. โ s๋ ์๋ฌธ ์ํ๋ฒณ ๋์๋ฌธ์ ๋๋ 0๋ถํฐ 9๊น์ง ์ซ์๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. s return "a234" false "1234" true ๋ฌธ์ ํ์ด s๋ฌธ์์ด์ ๊ธ์์๊ฐ 4์ ํน์ 6์์ผ ๊ฒฝ์ฐ !isNaN(s)๋ฅผ ํตํด ์ซ์์ธ์ง๋ฅผ ํ๋ณํด์ฃผ๊ณ ์๋ ๊ฒฝ์ฐ์๋ false๋ฅผ ๋ฐํ์ํค๋๋ก ํ๋ค. ๊ฒฐ๋ก ์ ์ผ๋ก s์ "a234"๊ฐ ๋ค์ด๊ฐ๋ "1234"๊ฐ ๋ค์ด๊ฐ๋ !isNaN์ ํตํด ์ซ์์ธ์ง๋ฅผ ํ๋ณํ๋๋ก ๋์ด์๊ณ "a234"์ ๊ฒฝ์ฐ๋ ๋ฌธ.. 2022. 11. 14. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๊ฐ์ด๋ฐ ๊ธ์ ๊ฐ์ ธ์ค๊ธฐ ๊ฐ์ด๋ฐ ๊ธ์ ๊ฐ์ ธ์ค๊ธฐ ๋จ์ด s์ ๊ฐ์ด๋ฐ ๊ธ์๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ๋ง๋ค์ด ๋ณด์ธ์. ๋จ์ด์ ๊ธธ์ด๊ฐ ์ง์๋ผ๋ฉด ๊ฐ์ด๋ฐ ๋๊ธ์๋ฅผ ๋ฐํํ๋ฉด ๋ฉ๋๋ค. ์ ํ ์กฐ๊ฑด โ s๋ ๊ธธ์ด๊ฐ 1 ์ด์, 100์ดํ์ธ ์คํธ๋ง์ ๋๋ค. s return "abcde" "c" "qwer" "we" ๋ฌธ์ ํ์ด ๋ฌธ์์ด์ด ๋ค์ด๊ฐ s๋ฅผ substr๋ฅผ ์ด์ฉํด s์ ๊ธ์์๋ฅผ 2๋ก ๋๋ด์ ๋ ๋ฑ ๋๋์ด์ง๋ ๊ฒฝ์ฐ(=์ง์)์๋ 2๋ฅผ, ์๋ ๊ฒฝ์ฐ(=ํ์) 1์ ๋ฌธ์์ด์ 2๋ก ๋๋ ๊ฐ์์ 1์ ๋บ ๊ฐ์์ ๋นผ๋๋ก ์คํฌ๋ฆฝํธ๋ฅผ ์ง ๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก s๊ฐ "abcde"์ผ ๊ฒฝ์ฐ 3-1==2์์ 1๊น์ง์ด๋ฏ๋ก ๋๋ฒ์งธ ์๋ฆฌ์์ ์ฒซ๋ฒ์งธ ์๋ฆฌ ์ฌ์ด์ ๊ธ์์ธ 'c'๋ฅผ ๋ฐํ์ํจ๋ค. function solution(s) { return s.substr(Math.ceil(.. 2022. 11. 14. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๊ฐ์ ์ซ์๋ ์ซ์ด ๊ฐ์ ์ซ์๋ ์ซ์ด ๋ฐฐ์ด arr๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ฐฐ์ด arr์ ๊ฐ ์์๋ ์ซ์ 0๋ถํฐ 9๊น์ง๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ์ด๋, ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๋ถ ์ ๊ฑฐํ๋ ค๊ณ ํฉ๋๋ค. ๋จ, ์ ๊ฑฐ๋ ํ ๋จ์ ์๋ค์ ๋ฐํํ ๋๋ ๋ฐฐ์ด arr์ ์์๋ค์ ์์๋ฅผ ์ ์งํด์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค๋ฉด, arr = [1, 1, 3, 3, 0, 1, 1] ์ด๋ฉด [1, 3, 0, 1] ์ return ํฉ๋๋ค. arr = [4, 4, 4, 3, 3] ์ด๋ฉด [4, 3] ์ return ํฉ๋๋ค. ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ์ ๊ฑฐํ๊ณ ๋จ์ ์๋ค์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด โ ๋ฐฐ์ด arr์ ํฌ๊ธฐ : 1,000,000 ์ดํ์ ์์ฐ์ โ ๋ฐฐ์ด arr์ ์์์ ํฌ๊ธฐ :.. 2022. 11. 11. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์๋ฐ์๋ฐ์๋ฐ์๋ฐ์๋ฐ์? ์๋ฐ์๋ฐ์๋ฐ์๋ฐ์๋ฐ์? ๊ธธ์ด๊ฐ n์ด๊ณ , "์๋ฐ์๋ฐ์๋ฐ์...."์ ๊ฐ์ ํจํด์ ์ ์งํ๋ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์๋ฅผ๋ค์ด n์ด 4์ด๋ฉด "์๋ฐ์๋ฐ"์ ๋ฆฌํดํ๊ณ 3์ด๋ผ๋ฉด "์๋ฐ์"๋ฅผ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค. ์ ํ ์กฐ๊ฑด * n์ ๊ธธ์ด 10,000์ดํ์ธ ์์ฐ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ n return 3 "์๋ฐ์" 4 "์๋ฐ์๋ฐ" ๋ฌธ์ ํ์ด for๋ฌธ์ ์ด์ฉํด์ i๋ฅผ n๋งํผ ์ฆ๊ฐ์์ผ์ค ๋ค์ answer์ i๊ฐ 2๋ก ๋๋์ด ๋จ์ด์ง๋ ์๋ค์ ๊ณ์ํด์ ์ ์ฅ์์ผ์ค๋ค. n์ด 3์ผ ๊ฒฝ์ฐ [1=์/2=๋ฐ/3=์]๋ก "์๋ฐ์"๊ฐ ์ถ๋ ฅ๋๊ณ , 4์ผ ๊ฒฝ์ฐ "์๋ฐ์๋ฐ"์ด ์ฑ๊ณต์ ์ผ๋ก ์ถ๋ ฅ๋๋ค. function solution(n) { let answer = ''; for(i=1; i "์๋ฐ".repeat(n).slice.. 2022. 11. 9. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : x๋งํผ ๊ฐ๊ฒฉ์ด ์๋ n๊ฐ์ ์ซ์ x๋งํผ ๊ฐ๊ฒฉ์ด ์๋ n๊ฐ์ ์ซ์ ํจ์ solution์ ์ ์ x์ ์์ฐ์ n์ ์ ๋ ฅ ๋ฐ์, x๋ถํฐ ์์ํด x์ฉ ์ฆ๊ฐํ๋ ์ซ์๋ฅผ n๊ฐ ์ง๋๋ ๋ฆฌ์คํธ๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค. ๋ค์ ์ ํ ์กฐ๊ฑด์ ๋ณด๊ณ , ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด * x๋ -10000000 ์ด์, 10000000 ์ดํ์ธ ์ ์์ ๋๋ค. * n์ 1000 ์ดํ์ธ ์์ฐ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ x n answer 2 5 [2,4,6,8,10] 4 3 [4,8,12] -4 2 [-4, -8] ๋ฌธ์ ํ์ด i๋ฅผ n๊ณผ ๊ฐ์์ง๊ธฐ ์ ๊น์ง ์ฆ๊ฐ์ํค๊ณ answer[i]์ answer[i-1]+x๋ฅผ ์ ์ฅ์ํจ๋ค. ๊ทธ๋ ๊ฒ ํ๋ฉด x์ (x * n)์ ๋ต ์ฌ์ด์ ์ซ์๋ค์ด x๋งํผ์ ๊ฐ๊ฒฉ์ผ๋ก answer์ ์ถ๋ ฅ๋๋ค. using namespace st.. 2022. 11. 9. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๋๋์ด ๋จ์ด์ง๋ ์ซ์ ๋ฐฐ์ด ๋๋์ด ๋จ์ด์ง๋ ์ซ์ ๋ฐฐ์ด array์ ๊ฐ element ์ค divisor๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ฐฐ์ด์ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. divisor๋ก ๋๋์ด ๋จ์ด์ง๋ element๊ฐ ํ๋๋ ์๋ค๋ฉด ๋ฐฐ์ด์ -1์ ๋ด์ ๋ฐํํ์ธ์. ์กฐ๊ฑด โ arr์ ์์ฐ์๋ฅผ ๋ด์ ๋ฐฐ์ด์ ๋๋ค. โ ์ ์ i, j์ ๋ํด i ≠ j ์ด๋ฉด arr[i] ≠ arr[j] ์ ๋๋ค. โ divisor๋ ์์ฐ์์ ๋๋ค. โ array๋ ๊ธธ์ด 1 ์ด์์ธ ๋ฐฐ์ด์ ๋๋ค. ๋ฌธ์ ํ์ด filter ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ฉด 0์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฐ์ ๋ฐฐ์ด๋ก ๋ง๋ค ์ ์์ผ๋ฉฐ, ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 0์ธ ์ฆ, divisor๋ก ๋๋์ด ๋จ์ด์ง๋ ์์๊ฐ ์์ ๋๋ -1์ ๋ฐฐ์ด๋ก ๋ฐํํ์์ผ๋ฉฐ ์๋ ๊ฒฝ์ฐ์๋ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด์ฃผ์๋ค. fu.. 2022. 11. 8. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์ ์ ์ ๊ณฑ๊ทผ ํ๋ณ ์ ์ ์ ๊ณฑ๊ทผ ํ๋ณ ์์์ ์์ ์ ์ n์ ๋ํด, n์ด ์ด๋ค ์์ ์ ์ x์ ์ ๊ณฑ์ธ์ง ์๋์ง ํ๋จํ๋ ค ํฉ๋๋ค. n์ด ์์ ์ ์ x์ ์ ๊ณฑ์ด๋ผ๋ฉด x+1์ ์ ๊ณฑ์ ๋ฆฌํดํ๊ณ , n์ด ์์ ์ ์ x์ ์ ๊ณฑ์ด ์๋๋ผ๋ฉด -1์ ๋ฆฌํดํ๋ ํจ์๋ฅผ ์์ฑํ์ธ์. ์ ํ ์กฐ๊ฑด - n์ 1์ด์, 50000000000000 ์ดํ์ธ ์์ ์ ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ ์ ์ถ๋ ฅ ์#1 121์ ์์ ์ ์ 11์ ์ ๊ณฑ์ด๋ฏ๋ก, (11+1)๋ฅผ ์ ๊ณฑํ 144๋ฅผ ๋ฆฌํดํฉ๋๋ค. ์ ์ถ๋ ฅ ์#2 3์ ์์ ์ ์์ ์ ๊ณฑ์ด ์๋๋ฏ๋ก, -1์ ๋ฆฌํดํฉ๋๋ค. n return 121 144 3 -1 ๋ฌธ์ ํ์ด for๋ฌธ์ ํตํด i๋ฅผ ๊ณ์ ์ฆ๊ฐ์ํค๋๋ฐ ๊ทธ ์กฐ๊ฑด์ for๋ฌธ ๊ดํธ ์์ ์ฃผ๋ ๋ฐฉ์์ด ์๋ for๋ฌธ ์์ if๋ฌธ์ ์ฐ๋ ๋ฐฉ์์ผ๋ก ์กฐ๊ฑด์ ์ ์ํ๋๋ก ํ๋ค. i*i๊ฐ n๋ณด.. 2022. 11. 5. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๋ ์ ์ ์ฌ์ด์ ํฉ ๋ ์ ์ ์ฌ์ด์ ํฉ ๋ ์ ์ a, b๊ฐ ์ฃผ์ด์ก์ ๋ a์ b ์ฌ์ด์ ์ํ ๋ชจ๋ ์ ์์ ํฉ์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์๋ฅผ ๋ค์ด a = 3, b = 5์ธ ๊ฒฝ์ฐ, 3 + 4 + 5 = 12์ด๋ฏ๋ก 12๋ฅผ ๋ฆฌํดํฉ๋๋ค. ์ ํ ์กฐ๊ฑด - a์ b๊ฐ ๊ฐ์ ๊ฒฝ์ฐ๋ ๋ ์ค ์๋ฌด ์๋ ๋ฆฌํดํ์ธ์. - a์ b๋ -10,000,000 ์ด์ 10,000,000 ์ดํ์ธ ์ ์์ ๋๋ค. - a์ b์ ๋์๊ด๊ณ๋ ์ ํด์ ธ์์ง ์์ต๋๋ค. ์ ์ถ๋ ฅ ์ a b return 3 5 12 3 3 3 5 3 12 ๋ฌธ์ ํ์ด if, else if๋ฌธ์ ํตํด a์ b๊ฐ ๊ฐ์ ๊ฒฝ์ฐ๋ a๋ฅผ ์ถ๋ ฅ์ํค๊ณ a๋ณด๋ค b๊ฐ ํฐ ๊ฒฝ์ฐ๋ a+(a+1)+b๋ฅผ, a๊ฐ ๋ ํฐ ๊ฒฝ์ฐ๋ a+(a-1)+b๋ฅผ answer์ ์ ์ฅ์์ผ ์ต์ข ์ ์ผ๋ก 3+4+5, 5+4+.. 2022. 11. 5. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ์์ธ์์ ๊น์๋ฐฉ ์ฐพ๊ธฐ ์์ธ์์ ๊น์๋ฐฉ ์ฐพ๊ธฐ Stringํ ๋ฐฐ์ด seoul์ element์ค "Kim"์ ์์น x๋ฅผ ์ฐพ์, "๊น์๋ฐฉ์ x์ ์๋ค"๋ String์ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํ์ธ์. seoul์ "Kim"์ ์ค์ง ํ ๋ฒ๋ง ๋ํ๋๋ฉฐ ์๋ชป๋ ๊ฐ์ด ์ ๋ ฅ๋๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค. ์ ํ ์กฐ๊ฑด - seoul์ ๊ธธ์ด 1 ์ด์, 1000 ์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค. - seoul์ ์์๋ ๊ธธ์ด 1 ์ด์, 20 ์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค. - "Kim"์ ๋ฐ๋์ seoul ์์ ํฌํจ๋์ด ์์ต๋๋ค. ์ ์ถ๋ ฅ ์ seoul return ["Jane", "Kim"] "๊น์๋ฐฉ์ 1์ ์๋ค" ๋ฌธ์ ํ์ด ์์ seoul์๋ ["Jane", "Kim"] ๋ ๊ฐ์ ๋ฐ์ดํฐ ๊ฐ์ด ๋ค์ด๊ฐ ์์ผ๋ฉฐ ์ด ์ค 1๋ฒ์งธ ๋ฐ์ดํฐ ๊ฐ์ "Kim"์ด๋ค. seoul.inde.. 2022. 11. 5. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๋ฌธ์์ด ๋ด p์ y์ ๊ฐ์ ๋ฌธ์์ด ๋ด p์ y์ ๊ฐ์ ๋๋ฌธ์์ ์๋ฌธ์๊ฐ ์์ฌ์๋ ๋ฌธ์์ด s๊ฐ ์ฃผ์ด์ง๋๋ค. s์ 'p'์ ๊ฐ์์ 'y'์ ๊ฐ์๋ฅผ ๋น๊ตํด ๊ฐ์ผ๋ฉด True, ๋ค๋ฅด๋ฉด False๋ฅผ return ํ๋ solution๋ฅผ ์์ฑํ์ธ์. 'p', 'y' ๋ชจ๋ ํ๋๋ ์๋ ๊ฒฝ์ฐ๋ ํญ์ True๋ฅผ ๋ฆฌํดํฉ๋๋ค. ๋จ, ๊ฐ์๋ฅผ ๋น๊ตํ ๋ ๋๋ฌธ์์ ์๋ฌธ์๋ ๊ตฌ๋ณํ์ง ์์ต๋๋ค. ์๋ฅผ ๋ค์ด s๊ฐ "pPoooyY"๋ฉด true๋ฅผ returnํ๊ณ "Pyy"๋ผ๋ฉด false๋ฅผ returnํฉ๋๋ค. ์ ํ ์กฐ๊ฑด - ๋ฌธ์์ด s์ ๊ธธ์ด : 50 ์ดํ์ ์์ฐ์ - ๋ฌธ์์ด s๋ ์ํ๋ฒณ์ผ๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ์ ์ถ๋ ฅ ์ s answer "pPoooyY" true "Pyy" false - ์ ์ถ๋ ฅ ์ #1 'p'์ ๊ฐ์ 2๊ฐ, 'y'์ ๊ฐ์ 2๊ฐ๋ก ๊ฐ์ผ๋ฏ๋ก true๋ฅผ r.. 2022. 11. 3. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๋ฌธ์์ด์ ์ ์๋ก ๋ฐ๊พธ๊ธฐ ๋ฌธ์์ด์ ์ ์๋ก ๋ฐ๊พธ๊ธฐ ๋ฌธ์์ด s๋ฅผ ์ซ์๋ก ๋ณํํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์ ํ ์กฐ๊ฑด - s์ ๊ธธ์ด๋ 1 ์ด์ 5์ดํ์ ๋๋ค. - s์ ๋งจ์์๋ ๋ถํธ(+, -)๊ฐ ์ฌ ์ ์์ต๋๋ค. - s๋ ๋ถํธ์ ์ซ์๋ก๋ง ์ด๋ฃจ์ด์ ธ์์ต๋๋ค. - s๋ "0"์ผ๋ก ์์ํ์ง ์์ต๋๋ค. ์ ์ถ๋ ฅ ์ ์๋ฅผ๋ค์ด str์ด "1234"์ด๋ฉด 1234๋ฅผ ๋ฐํํ๊ณ , "-1234"์ด๋ฉด -1234๋ฅผ ๋ฐํํ๋ฉด ๋ฉ๋๋ค. str์ ๋ถํธ(+,-)์ ์ซ์๋ก๋ง ๊ตฌ์ฑ๋์ด ์๊ณ , ์๋ชป๋ ๊ฐ์ด ์ ๋ ฅ๋๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค. ๋ฌธ์ ํ์ด atoi๋ผ๋ ํจ์ ์์ ๋ณ์๋ฅผ ๋ฃ์ผ๋ฉด ๋ฌธ์์ด์ ์ซ์๋ก ๋ฐ๊ฟ ์ ์๋ค. "1234"๊ฐ ๋ด๊ธด s ๋ณ์๋ฅผ atoi() ํจ์ ์์ ๋ฃ์ผ๋ฉด ์ซ์ 1234๋ก ๋ฐํ๋๋ค. #include #include #include i.. 2022. 11. 2. [Algorithm] ํ๋ก๊ทธ๋๋จธ์ค Lv.1 : ๋ถ์กฑํ ๊ธ์ก ๊ณ์ฐํ๊ธฐ ๋ถ์กฑํ ๊ธ์ก ๊ณ์ฐํ๊ธฐ ์๋ก ์๊ธด ๋์ด๊ธฐ๊ตฌ๋ ์ธ๊ธฐ๊ฐ ๋งค์ฐ ๋ง์ ์ค์ด ๋์ด์ง ์์ต๋๋ค. ์ด ๋์ด๊ธฐ๊ตฌ์ ์๋ ์ด์ฉ๋ฃ๋ price์ ์ธ๋ฐ, ๋์ด๊ธฐ๊ตฌ๋ฅผ N ๋ฒ ์งธ ์ด์ฉํ๋ค๋ฉด ์๋ ์ด์ฉ๋ฃ์ N๋ฐฐ๋ฅผ ๋ฐ๊ธฐ๋ก ํ์์ต๋๋ค. ์ฆ, ์ฒ์ ์ด์ฉ๋ฃ๊ฐ 100์ด์๋ค๋ฉด 2๋ฒ์งธ์๋ 200, 3๋ฒ์งธ์๋ 300์ผ๋ก ์๊ธ์ด ์ธ์๋ฉ๋๋ค. ๋์ด๊ธฐ๊ตฌ๋ฅผ count๋ฒ ํ๊ฒ ๋๋ฉด ํ์ฌ ์์ ์ด ๊ฐ์ง๊ณ ์๋ ๊ธ์ก์์ ์ผ๋ง๊ฐ ๋ชจ์๋ผ๋์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์. ๋จ, ๊ธ์ก์ด ๋ถ์กฑํ์ง ์์ผ๋ฉด 0์ return ํ์ธ์. ์ ํ ์ฌํญ - ๋์ด๊ธฐ๊ตฌ์ ์ด์ฉ๋ฃ price : 1 ≤ price ≤ 2,500, price๋ ์์ฐ์ - ์ฒ์ ๊ฐ์ง๊ณ ์๋ ๊ธ์ก money : 1 ≤ money ≤ 1,000,000,000, money๋ ์์ฐ์ - .. 2022. 11. 2. ์ด์ 1 2 ๋ค์ ๋ฐ์ํ