๐จ๐ป๐ป PS/JAVA
[JAVA] ๋ฐฑ์ค 2143๋ฒ ใG3.๋ ๋ฐฐ์ด์ ํฉใ
๋ฌธ์ 2143๋ฒ: ๋ ๋ฐฐ์ด์ ํฉ ์ฒซ์งธ ์ค์ T(-1,000,000,000 ≤ T ≤ 1,000,000,000)๊ฐ ์ฃผ์ด์ง๋ค. ๋ค์ ์ค์๋ n(1 ≤ n ≤ 1,000)์ด ์ฃผ์ด์ง๊ณ , ๊ทธ ๋ค์ ์ค์ n๊ฐ์ ์ ์๋ก A[1], …, A[n]์ด ์ฃผ์ด์ง๋ค. ๋ค์ ์ค์๋ m(1 ≤ m ≤ 1,000)์ด ์ฃผ์ด์ง๊ณ , ๊ทธ www.acmicpc.net ํ์ด ๊ฐ ๋ฐฐ์ด์ ๋ถ๋ถํฉ์ ์ ๋ถ ๊ตฌํ๋ค. List sumsA = new ArrayList(); n = Integer.parseInt(br.readLine()); A = Arrays.stream(br.readLine().split(" ")).mapToLong(Long::valueOf).toArray(); for (int i = 0; i < n; i++) { long res = 0;..
[JAVA] ๋ฐฑ์ค 18869๋ฒ ใG5.๋ฉํฐ๋ฒ์ค โ กใ
๋ฌธ์ 18869๋ฒ: ๋ฉํฐ๋ฒ์ค โ ก M๊ฐ์ ์ฐ์ฃผ๊ฐ ์๊ณ , ๊ฐ ์ฐ์ฃผ์๋ 1๋ถํฐ N๊น์ง ๋ฒํธ๊ฐ ๋งค๊ฒจ์ง ํ์ฑ์ด N๊ฐ ์๋ค. ํ์ฑ์ ํฌ๊ธฐ๋ฅผ ์๊ณ ์์๋, ๊ท ๋ฑํ ์ฐ์ฃผ์ ์์ด ๋ช ๊ฐ์ธ์ง ๊ตฌํด๋ณด๋ ค๊ณ ํ๋ค. ๊ตฌ์ฑ์ด ๊ฐ์๋ฐ ์์๋ง ๋ค๋ฅธ ์ฐ์ฃผ์ ์ www.acmicpc.net ํ์ด ์ ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด์๋ ์ขํ ์์ถ์ ์ฌ์ฉํด์ผํ๋ค. ์ขํ ์์ถ์ ๋ํ ๋ฌธ์ ๋ฅผ ํ๋ ํ์ด๋ณด๋ฉด ์ข๋ค. 18870๋ฒ: ์ขํ ์์ถ ์์ง์ ์์ N๊ฐ์ ์ขํ X1, X2, ..., XN์ด ์๋ค. ์ด ์ขํ์ ์ขํ ์์ถ์ ์ ์ฉํ๋ ค๊ณ ํ๋ค. Xi๋ฅผ ์ขํ ์์ถํ ๊ฒฐ๊ณผ X'i์ ๊ฐ์ Xi > Xj๋ฅผ ๋ง์กฑํ๋ ์๋ก ๋ค๋ฅธ ์ขํ Xj์ ๊ฐ์์ ๊ฐ์์ผ ํ๋ค. X1, X2, ..., XN์ www.acmicpc.net ์ขํ ์์ถ์ ํ๋ฉด ์๋์ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค. ์ฆ, ํน..
๋ฌธ์์ด ์์ ๊ณ์ฐํ๋ ๋ฉ์๋ ๋ง๋ค๊ธฐ
์ต๊ทผ, ํ ๊ธฐ์ ์์ ๋ผ์ด๋ธ ์ฝํ ๋ฅผ ๋ณด๋๋ฐ ๋ช ํํ๊ฒ ํ์ง ๋ชปํ๋ ๋ฌธ์ ๋ฅผ ๋ค์ ํ์ด๋ณด๋ ค๊ณ ํ๋ค. ์กฐ๊ฑด 1. ๋ฌธ์์ด์ ๊ณ์ฐํ ์ ์๋ ์์ผ๋ก ์ฃผ์ด์ง๋ค. 2. ์ซ์๋ ๋ชจ๋ ์์๋ก ์ฃผ์ด์ง๋ค. 3. ์ฐ์ฐ์ +, -, * ๋ง ์ฃผ์ด์ง๋ค. ํ ์คํธ ์ผ์ด์ค 1. ์ ๋ ฅ๊ฐ : "20+33-2*5" ๊ฒฐ๊ณผ : 43 2. ์ ๋ ฅ๊ฐ : "5-7*2+3" ๊ฒฐ๊ณผ : -6 ํ์ด ์ซ์์ ์ฐ์ฐ์๋ฅผ ๋ถ๋ฆฌํ๊ธฐ ์์์ ๊ณ์ฐํ๊ธฐ ์ํด์๋ ์ซ์์ ์ฐ์ฐ์๋ฅผ ๋ถ๋ฆฌํ๋ ๊ฒ์ด ํ์ํ๋ค๊ณ ์๊ฐํ๋ค. ๋ฌธ์์ด์ ๋ค๋ฃจ๋๋ฐ ์ ์ฉํ ์๋ฐ ์ ๊ท์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํด์ ๋ถ๋ฆฌํ ๋ค, ๋ฆฌ์คํธ์ ๋ด๋๋ค. public int sol(String input) { List list = new ArrayList(); Pattern p = Pattern.compile("\\d+|\\D")..
[JAVA] 2021 KAKAO BLIND RECRUITMENT ใํฉ์น ํ์ ์๊ธใ
๋ฌธ์ ์์ ์๊ตฌํ๋ ๋ต์ ๊ฐ๋ตํ๊ฒ ํํํ๋ฉด, (์ถ๋ฐ์ง์ → ๊ฒฝ์ ์ง์ ) ์๊ธ + (๊ฒฝ์ ์ง์ → ๋ฌด์ง ๋ชฉ์ ์ง) ์๊ธ + (๊ฒฝ์ ์ง์ → ์ดํผ์น ์ง์ ) ์๊ธ = ์ต์ข ์๊ธ ์ ์์ผ๋ก๋ถํฐ ๊ตฌํด์ง ์ต์ข ์๊ธ์ ์ต์๊ฐ์ ๋ต์ผ๋ก ์ถ๋ ฅํ๋ฉด ๋๋ค. ์ฒ์์ ํผ ๋ฐฉ์์ ์๊ฐ ์ด๊ณผ๊ฐ ๊ณ์ ๋ฐ์ํ๋๋ฐ for(int i=1;i
[JAVA] 2021 ์นด์นด์ค ์ฑ์ฉ์ฐ๊ณํ ์ธํด์ญ ใ๊ฑฐ๋ฆฌ๋๊ธฐ ํ์ธํ๊ธฐใ
๋งจํดํผ ๊ฑฐ๋ฆฌ๊ฐ ์ฌ์ค์, ํ ์ด๋ธ์ ์ ์ธํ ๋ ์์์ ์ฌ์ด์ ๊ฒฉ์ ๊ฑฐ๋ฆฌ์ด๋ฏ๋ก ๊ฐ ๋ฃธ๋ง๋ค, ์์์(P)๊ฐ ๋ฐ๊ฒฌ๋์ ๋ bfs()๋ฅผ ์คํ์์ผ ๊ทธ ์์์์ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ค๋ฅธ ์์์๋ฅผ ์ฐพ์๋๊น์ง ๋ฃจํ๋ฌธ์ ๋๋ฆฌ๊ณ ๋ฐ๊ฒฌ๋๋ฉด ๊ฑฐ๋ฆฌ๋ฅผ ๋ฆฌํดํ๋๋ก bfs()๋ฅผ ๊ตฌํํ์๋ค. ๊ฐ์ฅ ๊ฐ๊น์ด ์์์์ ๊ฑฐ๋ฆฌ๊ฐ 2์ดํ์ธ์ง ์ฒดํฌํ ๋ค, 2์ดํ๋ผ๋ฉด 0์ ๊ธฐ๋กํ๋๋ก ๋ก์ง์ ๊ตฌ์ฑํ์๋ค. import java.util.*; class Solution { String[][] map; boolean[][] checked; Queue q; int[] dr = {1,-1,0,0}; int[] dc= {0,0,1,-1}; public int[] solution(String[][] places) { int[] answer = new int[5]; Arra..
[JAVA] 2020 ์นด์นด์ค ์ธํด์ญ ใ์์ ์ต๋ํใ
๋ฌธ์์ด์ ์ด๋ป๊ฒ ์ฒ๋ฆฌํ ๊น ๊ต์ฅํ ๋ง์ด ๊ณ ๋ฏผํ๋ ๋ฌธ์ ์๋ค. ์ ๊ท์์ ์ฌ์ฉํ๋๊ฒ ์ฝ๋๊ฐ ๋ ๊ฐ๊ฒฐํด์ง ๊ฒ ๊ฐ์์ ์ ๊ท์์ ์ฌ์ฉํ๋ค. ๊ทธ๋ฆฌ๊ณ , ์ฐ์ฐ์๋ + - * 3๊ฐ๋ง ์ฃผ์ด์ง๊ธฐ ๋๋ฌธ์, ์ฐ์ฐ์ ์ฐ์ ์์๋ฅผ ์ง์ ๋ช ์ํด์ ์ ์ธํด์ฃผ์๋ค. "*+-","+*-","*-+","+-*","-*+","-+*" ์์ ๊ฐ์ 6๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ์์ ์ ์๋ค. ๋จผ์ ์ ๊ท์ "\\d+|\\S" ๋ฅผ ์ฌ์ฉํ๋ฉด, ์ซ์์ ์ฐ์ฐ์๋ก ๋๋ ์ ์๋ค. ๊ทธ๋ฆฌ๊ณ , ์ ๊ท์์ ๋ฐํ์ผ๋ก ๋ถ๋ฆฌํ ์์๋ค์, ์ํํ๋ฉด์ ์ซ์๋ผ๋ฉด ์คํ์ ์ง์ด๋ฃ๊ณ , ์ฐ์ฐ์์ด๋ฉด์ ์ฐ์ ์์์ ํด๋นํ๋ ์ฐ์ฐ์๋ผ๋ฉด ์คํ์ ์๋ ์ซ์๋ฅผ ๋นผ์ ์ฐ์ฐ์ฒ๋ฆฌ ํ ๋ค, ๋ฃ์ด๋๋ ๋ฐฉ์์ผ๋ก ํํ์์ ๋ณํ์์ผฐ๋ค. ์ฐ์ ์์๊ฐ "*+-" ๋ผ๊ณ ๊ฐ์ ํ์๋ "100-200*300-500+20" ์ด ์์ "100-..
[JAVA] 2019 ์นด์นด์ค ๊ฐ๋ฐ์ ๊ฒจ์ธ ์ธํด์ญ ใ์ง๊ฒ๋ค๋ฆฌ ๊ฑด๋๊ธฐใ
์ผ๋จ stones ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 200000๊ฐ์ด๋ฏ๋ก, ์ด์ค for๋ฌธ์ ์ ๋ ์ฌ์ฉํ๋ฉด ์๋๋ค. ๋ฐ๋ผ์ ๋ฐฐ์ด์ ์์๊ฐ์ผ๋ก ์ด๋ถ ํ์์ ํด์ ๊ฐ์ ์ฐพ์์ผ ํ๋ค. [2, 4, 5, 3, 2, 1, 4, 2, 5, 1] ์์ ์ฒ๋ผ ์์ ๊ฐ์ ๊ฒฝ์ฐ์์ ์ ์ฒด 3์ ๊ฐ์ํ๋ฉด [-1 1 2 0 -1 -2 1 -1 2 -2] ๊ฐ ๋๋๋ฐ, 0์ดํ์ธ ์์๊ฐ 3๊ฐ ์ฐ์์ผ๋ก ์กด์ฌํ๋ ๊ตฌ๊ฐ์ด ์๊ธฐ๋ฏ๋ก ๋ต์ด 3์ด ๋๋๊ฒ์ด๋ค. ๋ง์ฝ 2๋ฅผ ๊ฐ์ํ๋ฉด [0 2 3 1 0 -1 2 0 3 -1] ์ด ๋์ด 0์ดํ์ธ ์์๊ฐ 3๊ฐ ์ฐ์์ผ๋ก ์กด์ฌํ์ง ์๊ธฐ ๋๋ฌธ์ ๋ค์ ์ฌ๋์ด ๊ฑด๋๊ฐ ์ ์๋ค. ๋ฐ๋ผ์, ์ ์ฒด์ x๋ฅผ ๊ฐ์์์ผฐ์ ๋, 0์ดํ์ธ ๋์ด ์ฐ์์ผ๋ก k๊ฐ ์ด์ ์กด์ฌํ๋ x๊ฐ์ ์ด๋ถํ์์ผ๋ก ๊ตฌํ๋ฉด ๋๋ค. ์ด๊ธฐ๊ฐ์ left = stones ๋ฐฐ์ด์ ์ต..
[JAVA] 2018 KAKAO BLIND RECRUITMENT ใ๋ฐฉ๊ธ๊ทธ๊ณกใ
๋จผ์ C ๋ฉ๋ก๋์ C#์ ๋ค๋ฅธ ๋ฉ๋ก๋๋ก ์ทจ๊ธ๋๊ธฐ ๋๋ฌธ์, #์ด ๋ถ์ ์ฝ๋๋ convert ๋ฉ์๋๋ก, ๋ชจ๋ ๋ค๋ฅธ ์ํ๋ฒณ์ผ๋ก ๋ณํ์์ผ์ฃผ์๋ค. ๊ทธ๋ฆฌ๊ณ getTimeDiff() ๋ฉ์๋๋ฅผ ์ ์ํด์, ๋ ธ๋๊ฐ ์ฌ์๋ ์๊ฐ์ ๊ตฌํ๋ค. ๋ ธ๋๊ฐ ์ฌ์๋ ์๋งํผ ์ฝ๋๋ฅผ ๋์ดํ๊ธฐ ์ํด์ getFullMusic์ ๊ตฌํํ๋ค. ๋ฉ๋ก๋ ๊ฐ์๋ก ์ฌ์๋ ์๊ฐ์ ๋๋๊ณ , 1๋ณด๋ค ์๋ค๋ฉด ์ฌ์๋ ์๊ฐ๋งํผ์ผ๋ก substring ํ๊ณ 1๋ณด๋ค ํฌ๋ค๋ฉด, ๋๋ ๋ชซ +1 ๋งํผ ๋ฐ๋ณตํ ๋ค, substring์ผ๋ก ์ ์ฒด ๊ณก ๋ฉ๋ก๋๋ฅผ ๊ตฌํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋์, indexOf ํจ์๋ก ๋ฉ๋ก๋๊ฐ ํฌํจ๋ ๊ณก์ ์ฐพ๊ณ , ์ฌ์ ์๊ฐ ์, ์ ๋ ฅ๋ ์์ ์์ผ๋ก ์ ๋ ฌํ ๋ค ๋ฐํํ๋ฉด ๋๋ค. import java.util.*; class Solution { public String so..
[JAVA] 2020 KAKAO BLIND RECRUITMENT ใ๊ดํธ ๋ณํใ
์ฒ์์ )()(() ์ธ ๊ฒฝ์ฐ u= [ )( ] ์ v= [ )(() ] ๋ก ๋๋ ๋ค "()" + "()" +"()" ๊ฐ ๋์ด์ "()()()" ์ธ์ค ์์์ง๋ง, ๊ณผ์ ์ด ์ข ๋ฌ๋๋ค. )( ์์ ์ ๋ค ๋ฌธ์์ด์ ์ ๊ฑฐํ๋ฉด "" ๋น ๋ฌธ์์ด๋ง ๋จ๋๋ค. ๋ฐ๋ผ์, '(' ๋ฅผ ๋ถ์ด๊ณ v= [ )(() ] ๋ฅผ ๋ค์ 1๋จ๊ณ๋ถํฐ ์งํํ ๋ฌธ์์ด์ ๋ถ์ด๊ณ ')' ๋ฅผ ๋ถ์ธ๋ค. v = [ )(() ] ๋ฅผ ๋ค์ 1๋จ๊ณ๋ฅผ ์์ํ๋ฉด u = [ )( ] ์ v = [ () ] ๋ก ๋๋ ์ ์์ผ๋ฏ๋ก u๋ ๋ ๋ค์ ๋น ๋ฌธ์์ด์ด ๋๊ณ '(' ๋ฅผ ๋ถ์ด๊ณ v = [ () ] ๋ฅผ ๋ค์ 1๋จ๊ณ๋ถํฐ ์งํํ ๋ฌธ์์ด์ ๋ถ์ด๊ณ ')' ๋ฅผ ๋ถ์ธ๋ค. v๋ฅผ ๋์์ผ๋ก ๋ 1๋จ๊ณ๋ฅผ ์งํํ๋ฉด, ์์ ๋ฌธ์์ด์ด๋ฏ๋ก () ๊ฐ ๋ฐํ๋๋ค. ๋ฐ๋ผ์ ์ผ๋ จ์ ๊ณผ์ ์ run() ์ด๋ผ๊ณ ..
[JAVA] 2019 ์นด์นด์ค ๊ฐ๋ฐ์ ๊ฒจ์ธ ์ธํด์ญ ใ๋ถ๋ ์ฌ์ฉ์ใ
๋ฐฑํธ๋ํน ๋ฐฉ์์ผ๋ก, banned_id์ ํด๋นํ๋ ๊ฐฏ์๋งํผ์ ์กฐํฉ์ ๋ชจ๋ ๊ตฌํ๋ค.(getAllCases) ๊ทธ ์กฐํฉ ์์๊ฐ, banned_id์ ์๋ ์ ๊ท์ ์์๋๋ก ๋งค์นญํ์ ๋ ์ผ์นํ๋ฉด(checkRegex) ์ ๋ ฌํ๋ค์ Set ์๋ฃ๊ตฌ์กฐ์ ๋ฃ๋๋ค.(addAns) Set์ ์ ๋ค๋ฆญ ํ์ ์ String์ผ๋ก ํ์๋๋ฐ, ์กฐํฉ์ ๋ฌธ์์ด๋ก ๊ทธ๋๋ก ๋ํ๊ฒ์ผ๋ก ์ค๋ณต์ฒดํฌ๋ฅผ ํ์๋ค. ์์ด๋์ด๋ฅผ ๋ ์ฌ๋ฆฌ๋๊ฒ ์๊ฐ๋ณด๋ค ๊ธ๋ฐฉ ๋ ์ค๋ฅด์ง ์์๊ณ , ์ฒ์์ ๋ฌธ์ ๋ฅผ ํ์์๋๋ ๋๋ฌด ๊ฐ๋ ์ฑ ์์ด ํ์์ด์ ๋ค์ ํ์๋ ๋ฌธ์ ๋ค. import java.util.*; import java.util.regex.*; class Solution { Stack s; HashSet set; HashSet ans; public int solution(String[..
[JAVA] 2018 KAKAO BLIND RECRUITMENTใํ๋์ฆ4๋ธ๋กใ
์ฝ๋๋ ์คํ์ธ๊ฐใ ใ ใ ๋ญ๊ฐ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ์๋ค๋ ๋๋๋ณด๋ค๋ ํ๋ก๊ทธ๋จ์ ํ๋ ๋ง๋ ๋๋์ด๋ค. ๋ฌธ์ ์์ฒด๋ ์ฌ์ ๊ณ , ๊ฐ์ฅ ํท๊ฐ๋ ธ๋ ๋ถ๋ถ์ ๋ธ๋ก์ ์ ๊ฑฐํ๊ณ ์ฎ๊ธฐ๋ ๋ถ๋ถ์ด์๋ค. ์ด๋ถ๋ถ์, StringBuilder๋ฅผ ์ฌ์ฉํด์ ํด๊ฒฐํ๋๋ฐ, ๋๋ ์ ๊ฑฐํ ๋ธ๋ก์ "0"์ผ๋ก ๊ธฐ๋กํด๋์์๋ค. ๋ฐ๋ผ์, ์์ ๊ฐ์ ์ํฉ์์, ์ฒซ๋ฒ์งธ ์ด์ ์ถ๋ ฅํ๋ฉด, TTT00T ์ ๊ฐ์ด ์ถ๋ ฅ๋๋ค. ๋ฐ๋ผ์, 0์ด ์๋๊ฒฝ์ฐ์๋ง StringBuilder์ ํฉ์ณ์ฃผ๋ฉด, TTTT ๋ฅผ ์ป์ ์ ์๋ค. ๊ทธ๋ฆฌ๊ณ ํ์ ๊ฐฏ์๊ฐ ์ผ์นํด์ผํ๋ฏ๋ก ํ์ ๊ฐฏ์๋งํผ "0"์ ๋ํ๋ฉด TTTT00 ์ด ๋๋ค. ๋๋ฒ์งธ ์ด์ ์๋ก ํ๋ฒ ๋ ์ค๋ช ํด๋ณด๋ฉด, MT000T ์ธ ์ํฉ์์ MTT ๋ก ๋ง๋ ๋ค, MTT000 ์ผ๋ก ๋ง๋ค์ด์ฃผ๋ ๊ฒ์ด๋ค. ์ด๋ ๊ฒ ๋ณํํ ๋ฌธ์๋ฅผ map์ ์ด ๋จ์๋ก ๊ธฐ..
[JAVA] 2019 KAKAO BLIND RECRUITMENTใ์คํ์ฑํ ๋ฐฉใ
map์ ๋ก ์ ์ฅํด ๋๊ฐ๋ค. Enter๋ก ์ ๋ ฅ๋๋ฉด ์ ๋ ฅ๋ ๋๋ง๋ค map์ ๋ฐ๋ก ์ ๋ ฅ๊ณผ ์ ๋ฐ์ดํธ๋ฅผํ๊ณ , Change์ธ ๊ฒฝ์ฐ์๋ ์ ๋ฐ์ดํธ๋ง ํด์ฃผ๋ฉด ๊ฐ๋จํ๊ฒ ํด๊ฒฐ๋๋ค. ์ธ๋ถ์์ ๋๋ค์์ ๋ฐ๊พธ๊ณ ๋ค์ด์ค๋ ๊ฒฝ์ฐ๋ Enter๋ก ์ฒ๋ฆฌ๋๊ธฐ ๋๋ฌธ์ ์ ๊ฒฝ์ธ ํ์๊ฐ ์๋ค. import java.util.*; class Solution { HashMap map; public String[] solution(String[] record) { String[] answer = {}; map = new HashMap(); for(String rec : record){ String [] info = rec.split(" "); if(info[0].equals("Enter")){ map.put(info[1],info[2]); }else ..
[JAVA] 2022 KAKAO BLIND RECRUITMENTใ์ฃผ์ฐจ ์๊ธ ๊ณ์ฐใ
๋ฌธ์ ์์ฒด๋ ๊ฐ๋จํ๋ค, ์ฝ๋๋์ด ๋ง์์ ๋ฟ.ใ HashMap ์๋ฃํ์ ์ด์ฉํด์, ์๋์ฐจ๊ฐ IN ์ธ ๊ฒฝ์ฐ [์๋์ฐจ ๋ฒํธ = key, ์๋์ฐจ ์ ์ฐจ์๊ฐ = value] ๋ก ์ ์ฅํ๋ค. ์๋์ฐจ๊ฐ OUT์ธ ๊ฒฝ์ฐ map์์ ์ ์ฐจ์๊ฐ์ ์ถ์ถํ ๋ค, ์ด์ฉ์๊ฐ์ ๊ตฌํ๋ค. ์ด์ฉ์๊ฐ์, ๋ค๋ฅธ map์ [์๋์ฐจ ๋ฒํธ = key , ์ฃผ์ฐจ์ฅ ์ด์ฉ์๊ฐ = value ] ๋ก ๊ธฐ๋กํด๋๊ณ , ์ ์ฐจ์๊ฐ์ ๊ธฐ๋กํ๋ map์ ์๋ ๋ฐ์ดํฐ๋ ์ญ์ ํ๋ค. ์ญ์ ํ๋ ์ด์ ๋, ๋์ค์ ์ถ์ฐจ ๋ด์ญ์ด ์๋ outํ์ง ๋ชปํ ์ฐจ๋ฅผ ํ์ธํ๊ธฐ ์ํด์์ด๋ค. ๊ทธ๋ ๊ฒ, ์ด์ฉ์๊ฐ์ ๋ค ๊ธฐ๋กํ ๋ค, ์ถ์ฐจํ์ง ๋ชปํ ์ฐจ๊ฐ ์๋์ง ํ์ธํ๊ณ , ์ด์ฉ์๊ฐ์ ์ถ๊ฐํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ฃผ์ด์ง ์๊ธ ์ ์ฐ ๋ฐฉ๋ฒ๋๋ก ๊ณ์ฐํ ๋ค, ์๋์ฐจ ๋ฒํธ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด์ ๋ฐํํ๋ฉด ๋์ด๋ค // ์ ์ฐจ ์ดํ ์ถ์ฐจ ..
[JAVA] 2018 KAKAO BLIND RECRUITMENTใn์ง์ ๊ฒ์ใ
10์ง๋ฒ ์๋ฅผ n์ง๋ฒ์ ๋ง๋ ๋ฌธ์์ด๋ก ๋ฐํํ๋ convert() ๋ฉ์๋๋ฅผ ์ ์ํ์๊ณ 0๋ถํฐ n์ง๋ฒ์ผ๋ก ๋ณํํ ๋ฌธ์์ด์ ๊ณ์ ๋ํด์ ๊ธธ์ด๊ฐ t*m ์ด์์ด ๋ ๋๊น์ง ๋ํ๋ค. ๊ฒ์์ ์ฐธ๊ฐํ๋ ์ธ์์ด m๋ช ์ด๊ณ , ๋ฏธ๋ฆฌ ๊ตฌํ ์ซ์๊ฐ t์ผ๋, ๋ง์ฝ ํ๋ธ์ ์์๊ฐ m๋ช ์ค์ m๋ฒ์งธ ์์์ธ ๊ฒฝ์ฐ๊ฐ ์ ์ผ ๋ฆ์ ์์์ธ ๊ฒฝ์ฐ์ด๋ฏ๋ก ๋ฌธ์์ด์ t*m๊น์ง๋ง ๊ตฌํ๋ฉด ๋๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ฆฌ๊ณ do-while ๋ฃจํ๋ฌธ์ผ๋ก ์ฃผ์ด์ง ํ๋ธ์ ์์์ ๋ง๊ฒ t๊ฐ๊ฐ ๋ ๋๊น์ง ๋ฌธ์์ด์ ๋ํด์ ๋ต์ ๊ตฌํ๋ค. // ์ง๋ฒ n class Solution { String[] unit = {"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"}; public String solution(int n, in..
[JAVA] 2018 KAKAO BLIND RECRUITMENTใ์์ถใ
map์ ์ฌ์ฉํด์, ๊ธฐ๋ณธ์ ์ผ๋ก A~Z ๊น์ง ์ ์ฅํ ๋ค, map์ ํค๋ก ์กด์ฌํ์ง ์์ ๋๊น์ง idx๋ฅผ ++ํด์ ๋ฌธ์๋ฅผ ๋ํ๊ณ , map์ ์ถ๊ฐํด์ฃผ๋ ๋ฐฉ์์ผ๋ก ํ๋ฉด ๋๋ ๊ฐ๋จํ ๋ฌธ์ ์๋ค. import java.util.*; class Solution { HashMap map; List ans; public int[] solution(String msg) { setUp(); int idx = 0; while(idx