Algorithm
[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 ์ขํ ์์ถ์ ํ๋ฉด ์๋์ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค. ์ฆ, ํน..
[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] 2020 KAKAO BLIND RECRUITMENT ใ๊ดํธ ๋ณํใ
์ฒ์์ )()(() ์ธ ๊ฒฝ์ฐ u= [ )( ] ์ v= [ )(() ] ๋ก ๋๋ ๋ค "()" + "()" +"()" ๊ฐ ๋์ด์ "()()()" ์ธ์ค ์์์ง๋ง, ๊ณผ์ ์ด ์ข ๋ฌ๋๋ค. )( ์์ ์ ๋ค ๋ฌธ์์ด์ ์ ๊ฑฐํ๋ฉด "" ๋น ๋ฌธ์์ด๋ง ๋จ๋๋ค. ๋ฐ๋ผ์, '(' ๋ฅผ ๋ถ์ด๊ณ v= [ )(() ] ๋ฅผ ๋ค์ 1๋จ๊ณ๋ถํฐ ์งํํ ๋ฌธ์์ด์ ๋ถ์ด๊ณ ')' ๋ฅผ ๋ถ์ธ๋ค. v = [ )(() ] ๋ฅผ ๋ค์ 1๋จ๊ณ๋ฅผ ์์ํ๋ฉด u = [ )( ] ์ v = [ () ] ๋ก ๋๋ ์ ์์ผ๋ฏ๋ก u๋ ๋ ๋ค์ ๋น ๋ฌธ์์ด์ด ๋๊ณ '(' ๋ฅผ ๋ถ์ด๊ณ v = [ () ] ๋ฅผ ๋ค์ 1๋จ๊ณ๋ถํฐ ์งํํ ๋ฌธ์์ด์ ๋ถ์ด๊ณ ')' ๋ฅผ ๋ถ์ธ๋ค. v๋ฅผ ๋์์ผ๋ก ๋ 1๋จ๊ณ๋ฅผ ์งํํ๋ฉด, ์์ ๋ฌธ์์ด์ด๋ฏ๋ก () ๊ฐ ๋ฐํ๋๋ค. ๋ฐ๋ผ์ ์ผ๋ จ์ ๊ณผ์ ์ run() ์ด๋ผ๊ณ ..
[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
[JAVA] 2018 KAKAO BLIND RECRUITMENT ใ๋ด์ค ํด๋ฌ์คํฐ๋งใ
์ฃผ์ด์ง ๋ฌธ์์ด์ ๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ง๋ ์กฐํฉ์ ๋ง๋ค์ด์ Map์ ๊ฐ์์ ๊ธฐ๋กํ๋ค. (์์,["fr":2,"re":1,....]) ๋ ๋ฌธ์์ด์ ์กฐํฉ๋ณ ๊ฐฏ์๋ฅผ ๊ธฐ๋กํ Map์ ์ด์ฉํด์ ๊ต์งํฉ ์๋ฅผ ๊ตฌํ๋ค. ๊ต์งํฉ์๋ ์ค๋ณต๋ ํ์ฉํ๋ฏ๋ก, ๊ฐ Map์ ๊ธฐ๋ก๋์ด์๋ ์์ ์ต์๊ฐ์ผ๋ก ๊ธฐ๋กํ๋ค. ๊ทธ๋ฆฌ๊ณ (ํฉ์งํฉ ์ - ๊ต์งํฉ์)๊ฐ ๋ถ๋ชจ, ๊ต์งํฉ ์๊ฐ ๋ถ์๊ฐ ๋์ด ๋ต์ ๊ตฌํ๋ค. import java.util.*; class Solution { HashMap mapA; HashMap mapB; public int solution(String str1, String str2) { int answer = 0; mapA = new HashMap(); mapB = new HashMap(); getCombination(mapA,st..
[JAVA] 2022 KAKAO TECH INTERNSHIP ใ๋ ํ ํฉ ๊ฐ๊ฒ ๋ง๋ค๊ธฐใ
๋ฌธ์ ์์ฒด๋ ๊ฐ๋จํ๋ค. ์ผ์ชฝ ํ ์ดํฉ์ด ์ปค์ง๋ฉด, ์ผ์ชฝ ํ ์์๋ฅผ ๋นผ์ ์ค๋ฅธ์ชฝ ํ๋ก ์ฎ๊ธฐ๊ณ ์ค๋ฅธ์ชฝ ํ ์ดํฉ์ด ์ปค์ง๋ฉด ์ค๋ฅธ์ชฝ ํ ์์๋ฅผ ๋นผ์ ์ผ์ชฝ ํ๋ก ์ฎ๊ธฐ๋ฉด ๋๋ค. ๊ทธ๋ฆฌ๊ณ [1,4] [4,8] ๊ณผ ๊ฐ์ด ์ฃผ์ด์ง๋ฉด ๋ฌดํ ๋ฃจํ๊ฐ ๋ ์ ์๊ธฐ ๋๋ฌธ์, while๋ฌธ ํ์ถ ์กฐ๊ฑด์ (๋ ํ์ ๊ธธ์ด ํฉ*2) ์ด์ ๋ฐ๋ณต๋๋ฉด ํ์ถํ๋๋ก ์ค์ ํด๋จ๋ค. ์ต์ ์ ๊ฒฝ์ฐ๋ฅผ ๊ฐ์ ํด์ ์๊ฐํด๋ดค๋ค. ํ1 [1 2 3....n] // ํ 2 [1 2 3 ....m] ํ1 [n] // ํ 2[1 2 3 ...m 1 2 3....n-1] (์ฝ n-1๋ฒ ์์) ํ1[1 2 3 ....m] // ํ2[1 2 3 ....n] (์ฝ m+1๋ฒ ์์) ํ 1๊ณผ ํ2์ ์์๊ฐ ์์ ํ ๋ฐ๋๋ ค๋ฉด n+m๋ฒ์ด ์์๋๊ณ ๋ค์ ํ1์ด ์ฒ์ ํ1์์๋ก ๋์๊ฐ๋ ค๋ฉด n+m๋ฒ..
[JAVA] 2020 ์นด์นด์ค ์ธํด์ญ ใ๋ณด์ ์ผํใ
Map์ ์ด์ฉํด์ ๋ณด์ ์ข ๋ฅ๋ณ ๊ฐฏ์๋ฅผ ๊ธฐ๋กํ๋ค. ๊ทธ๋ฆฌ๊ณ L์ 0์ผ๋ก ์ก๊ณ , gems[L] ์ด Map์ ์กด์ฌํ๋ฉด์, ๊ฐ์ด 2์ด์์ผ๋ก ์กด์ฌํ๋ ๊ฒฝ์ฐ ๊ฐ์ด 1์ด ๋ ๋๊น์ง L์ ์ฆ๊ฐ์ํจ๋ค. ๊ทธ๋ฌ๋ฉด, ์ ์ผ ์์ชฝ์ ์ค๋ณต์ผ๋ก ์กด์ฌํ๋ ๋ณด์์ ์ ์ธ์ํฌ ์ ์๋ค. ๊ทธ๋ฆฌ๊ณ , Map์ size ์ฆ, ๊ธฐ๋ก๋ ๋ณด์์ ๊ฐฏ์๊ฐ ๋ณด์ ์ข ๋ฅ ์์ ์ผ์นํ๋ฉด ๋ชจ๋ ๋ณด์์ด ์กด์ฌํ๋ ๊ตฌ๊ฐ์์ ์๋ฏธํ๋ฏ๋ก ์ ๋ต์ ๊ฐฑ์ ํ๊ณ , ์ด๋ฏธ ๊ธฐ๋ก๋ ๊ธธ์ด๋ณด๋ค ์์ ๊ฒฝ์ฐ์๋ง ๊ฐฑ์ ํ๋ค. import java.util.*; class Solution { public int[] solution(String[] gems) { int[] answer = new int[2]; int cnt = new HashSet(Arrays.asList(gems)).size(); in..