๐จ๐ป๐ป PS/JAVA
[JAVA] 2022 KAKAO BLIND RECRUITMENTใk์ง์์์ ์์ ๊ฐ์ ๊ตฌํ๊ธฐใ
๋งค์ฐ ๊ฐ๋จํ๋ ๋ฌธ์ ์๋ค. k์ง์๋ก ๋ณํํ๋ transform ํจ์๋ฅผ ์ ์ํ๊ณ ๋ฐํ๋ฐ์ ๊ฐ์ ์ ๊ท์์ผ๋ก ์ซ์๋ฅผ ์ถ์ถํ๋ค. ์๋ผํ ์ค ํ ๋ค์ค ์ฒด๋ก ์์๋ฅผ ํ๋ณํ๋ ๋ฉ์๋๋ ์ ์ํด์ ์์๋ฅผ ํ๋ณํ๊ณ , ์ฃผ์ํ ์ ์ ๋ฌธ์์ด ์ซ์๊ฐ int ๋ฒ์๋ฅผ ์ด๊ณผํ์ฌ ์ด์ํ ๋ต์ ๋์ถํ ์ ์์ผ๋ฏ๋ก long ํ์ ์ผ๋ก ๋ฐ์์ ํ์ธํด์ผํ๋ค. import java.util.*; import java.util.regex.*; class Solution { public int solution(int n, int k) { int answer = 0; String num = transform(n,k); Pattern pattern = Pattern.compile("[1-9]+"); Matcher matcher = pattern.matcher..
[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..
[JAVA] 2021 KAKAO BLIND RECRUITMENT ใ๋ฉ๋ด ๋ฆฌ๋ด์ผใ
๋ฐฑํธ๋ํน์ผ๋ก ์์ ์กฐํฉ์ ๊ตฌํ ๋ค, ์์ ์กฐํฉ ๋ณ ์ฃผ๋ฌธ ํ์๋ฅผ ๊ตฌํ๋ค. (bt() ๋ฉ์๋ ์ฌ์ฉ) ์ ๊ฐ์ด ์ ๋ ฅ๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ์ด ๋งต์ ์ด์ฉํด์, ๋ฅผ ๊ตฌํ๋ค. (getMaxMenu()) ๊ทธ๋ฆฌ๊ณ ์ฝ์ค์ฌ์ด์ฆ๋ณ ์ต๋ ์ฃผ๋ฌธํ์๋ฅผ ์๊ฒ ๋์ผ๋ฏ๋ก, ์ฝ์ค ์ฌ์ด์ฆ์ ์์ ์กฐํฉ์ ๊ธธ์ด๊ฐ ์ผ์นํ๋ฉด์ [์ฃผ๋ฌธํ์์ ์ต๋ ์ฃผ๋ฌธํ์๊ฐ ์ผ์นํ ๊ฒ & 2๋ฒ ์ด์ ์ฃผ๋ฌธ ๋]๊ฒ์ Max ๊ฐ์ ๋ฆฌ์คํธ ์๋ฃ๊ตฌ์กฐ์ธ ans์ ๊ธฐ๋กํ๋ค. ์ ๋ ฌํ ๋ค, ๋ฐฐ์ด๋ก ๋ณํํด์ ๋ฐํํ๋ค import java.util.*; class Solution { HashMap map; HashMap max; List ans; StringBuilder sb; public String[] solution(String[] orders, int[] course) { map..
[JAVA] 2019 ์นด์นด์ค ๊ฐ๋ฐ์ ๊ฒจ์ธ ์ธํด์ญ ใํํใ
๋งต๊ณผ ๋ฆฌ์คํธ๋ฅผ ํ์ฉํด์ ํ์๋ค. ๋จผ์ ์ฝ๊ฒ ์๊ฐํ ์ ์๋ ์์ด๋์ด๊ฐ, ํน์ ์ซ์๊ฐ ๋ฑ์ฅํ๋ ํ์๋ฅผ ๊ตฌํ๊ณ ๋ฑ์ฅ์ ๋ง์ด ํ๋ ์์๋ก ๋์ดํ๋ฉด ๋ต์ด ๋ ๊ฒ์ด๋ค. "{{2},{2,1},{2,1,3},{2,1,3,4}}" ์ ์์ ๋ฅผ ์์๋ก ์ค๋ช ํด๋ณด๊ฒ ๋ค. int [] result = Arrays.stream(s.replace("{","").replace("}","").split(",")) .mapToInt(Integer::valueOf) .toArray(); ์ ๋ก์ง์ ํตํด [2, 2, 1, 2, 1, 3, 2, 1, 3, 4] ์ ๊ฐ์ int ๋ฐฐ์ด๋ก ์ถ์ถํ ์ ์๋ค. ์ด ๋ฐฐ์ด์ Map์ ์ด์ฉํด์ ์นด์ดํ ์ ํ๋ค. HashMap map = new HashMap(); for(int num : result){ map..
[JAVA] 2018 KAKAO BLIND RECRUITMENT ใ์บ์ใ
ํ๋ก ๊ฐ๋จํ๊ฒ ํด๊ฒฐํ ์ ์์๋ ๋ฌธ์ , ํ๋ฅผ ์บ์ ์ ์ฅ๊ณต๊ฐ์ฒ๋ผ ์ฌ์ฉํ๋ค. ํ๊ฐ ์ ํด์ง ์บ์ ์ฌ์ด์ฆ์ ๋๋ฌํ๋ฉด, poll() ํด์ค๋ค offer() ํด์ค๋ค. ๋ง์ฝ, ์บ์ ํํธ๊ฐ ๋๋ฉด, ์ต์ ์บ์๋ก ์ ๋ฐ์ดํธ ํด์ค์ผ ํ๋ฏ๋ก remove()ํด์ค ๋ค offer() ํด์ค๋ค. ์บ์์ฌ์ด์ฆ๊ฐ 0์ธ ๊ฒฝ์ฐ์ ["LA","la"] ์ ๋ ฅ์ด ์ฃผ์ด์ง๋ฉด ๋ต์ด 10์ด ๋์์ผ ํ๋ฏ๋ก, cache ์ฌ์ด์ฆ๊ฐ 0์ธ ๊ฒฝ์ฐ๋ง ๋ฐ๋ก ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ๋ฉด ๋๋ค. import java.util.*; class Solution { Queue cache; public int solution(int cacheSize, String[] cities) { int answer = 0; cache = new LinkedList(); if(cacheSize==0){ ret..
[ํ์ด์ฌ PYTHON] ํ๋ก๊ทธ๋๋จธ์ค ใ์ผ๊ฐ ๋ฌํฝ์ดใ
def solution(n): result = [] checked = [] # ์ต์ข ๋๋ฒ final = (n) * (n + 1) // 2 # ๊ทธ๋ํ์ ๋ฐฉ๋ฌธ ์ฌ๋ถ checked ์ด๊ธฐํ for i in range(1, n + 1): arr = [j + 1 for j in range(i)] chk = [False for j in range(i)] result.append(arr) checked.append(chk) # ์์ง์ผ ์ ์๋ ๋ฐฉํฅ ์ผ์ชฝ ์๋ ๋ฐฉํฅ ๋ถํฐ ์งํ dr = [1, 0, -1] dc = [0, 1, -1] direct = 0 # 0,0 1๋ฒ ๋ถํฐ ๋๋ฒ๋ง ์์ num = 1 r, c = 0, 0 while True: # ๋๋ฒ๋ง์ด ์ต์ข ๋๋ฒ์ ๋์ผํด์ง๋ฉด ๋ฃจํ ์ข ๋ฃ if num == final: re..
[ํ์ด์ฌ PYTHON] ํ๋ก๊ทธ๋๋จธ์ค ใ๋ค์ ์๋ ํฐ ์ ์ฐพ๊ธฐใ
์ง์ง ๋๋ฌด ์ด๋ ค์ ๋ค.. ๋ฌธ์ ๋ฅผ ๊ฒจ์ฐ ์ดํดํด๋ดค๊ณ ๋ด๊ฐ ์ดํดํ ๋ฐํ์ผ๋ก ์์ ๋ฅผ ํตํด ์ค๋ช ํด๋ณด๊ฒ ๋ค. stack์ ์ฌ์ฉํ ๊ฒ์ด๊ณ , stack์๋ ๊ฐ์ด ์๋ ์ธ๋ฑ์ค๋ฅผ ๊ฐฑ์ ํด ๋๊ฐ ๊ฒ์ด๋ค. ๋จผ์ ์ฒซ๋ฒ์งธ ์์(index = 0)์ธ 9๋ ๋น๊ต๋์์ด ์์ผ๋ฏ๋ก stack์ ๊ทธ๋ฅ ์ ๋ ฅํ๋ค. stack์ index๊ฐ ์์ง ์กด์ฌํ๋ค๋ ๋ป์ ์์ง ๋ท ํฐ์๋ฅผ ๋ง๋์ง ๋ชปํ๋ค๋ ์๋ฏธ์ด๋ค. ๊ทธ ๋ค์ ๋๋ฒ์งธ ์์(index = 1)์ ๊ฐ์ด 1์ด๊ณ stack์ ํ์ธํด์ ๋ท ํฐ ์๋ก์ ์ญํ ์ ํ ์ ์๋์ง ํ์ธํด๋ณธ๋ค. ํ์ง๋ง stack์ ์ ์ฅ๋์ด ์๋ ์ธ๋ฑ์ค๋ก ๊ฐ์ ํ์ธํด๋ณด๋ 1๋ณด๋ค ํฐ 9์ด๋ฏ๋ก ์๊ฑฐํ ์ ์๋ค. stack์ ๋ณํ ์์ด index 1์ ์คํ์ ์ถ๊ฐํ๋ค. ๊ทธ ๋ค์ 3๋ฒ์งธ ์์์ธ (index = 2) 5๊ฐ ๋ท ํฐ ์ ์ญํ ์ ํ ..
[ํ์ด์ฌ PYTHON · ์๋ฐ JAVA] ํ๋ก๊ทธ๋๋จธ์คใ์ด์ง ๋ณํ ๋ฐ๋ณตํ๊ธฐใ
์๋ฐ ์ฝ๋ class Solution { public int[] solution(String s) { int[] answer = {}; int zero = 0; int tran = 0; while(!s.equals("1")){ int numOfZero = 0; int numOfOne = 0; for(int i=0;i
[ํ์ด์ฌ PYTHON · ์๋ฐ JAVA] ํ๋ก๊ทธ๋๋จธ์คใ์ฌ๋ฐ๋ฅธ ๊ดํธใ
์๋ฐ ์ฝ๋ import java.util.*; class Solution { boolean solution(String s) { int result =0; for(int i=0;i
[ํ์ด์ฌ PYTHON · ์๋ฐ JAVA] ํ๋ก๊ทธ๋๋จธ์ค ใ์ต์๊ฐ ๋ง๋ค๊ธฐใ
์๋ฐ ์ฝ๋ import java.util.*; class Solution { public int solution(int []A, int []B) { int answer = 0; Arrays.sort(A); Arrays.sort(B); for(int i=0;i
[ํ์ด์ฌ PYTHON · ์๋ฐ JAVA] ํ๋ก๊ทธ๋๋จธ์คใ์ต๋๊ฐ๊ณผ ์ต์๊ฐใ
๋ฌธ์์ด์ ์ซ์ ๋ฐฐ์ด๋ก ๋ง๋ค์ด ์ค ๋ค, ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ๊ตฌํ๋ฉด ๋๋ ๊ฐ๋จํ ๋ฌธ์ ์ด๋ค. ํ์ด์ฌ์ ๊ฒฝ์ฐ max() ์ min() ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋๊ณ ์๋ฐ๋ Math.max() ์ Math.min() ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค. ์๋ฐ ์ฝ๋ import java.util.*; import java.io.*; class Solution { public String solution(String s) { int[] arr = Arrays.stream(s.split(" ")).mapToInt(str->Integer.valueOf(str)).toArray(); int max = arr[0]; int min = arr[0]; for(int num : arr){ max = Math.max(max,num); min = Math...
[ํ์ด์ฌ PYTHON · ์๋ฐ JAVA] ํ๋ก๊ทธ๋๋จธ์คใJadenCase ๋ฌธ์์ด ๋ง๋ค๊ธฐใ
๋ฌธ์ ํฌ์ธํธ : ๋ชจ๋ ๋ฌธ์๋ฅผ ์๋ฌธ์๋ก ๋ณํํ๋ค. ํ์ด์ฌ์ ๊ฒฝ์ฐ๋ .lower() ์๋ฐ์ ๊ฒฝ์ฐ๋ toLowerCase() ๋ฅผ ์ฌ์ฉ ๊ทธ๋ฆฌ๊ณ ์ฒซ ๋ฌธ์๋ง ์ํ๋ฒณ์ด๋ฉด ๋๋ฌธ์๋ก ์ง์ ๋ง๋ค์ด์ฃผ๊ณ , ๋๋จธ์ง๋ ๊ณต๋ฐฑ ๋ค์์ ์ค๋ ๋ฌธ์๊ฐ ์ํ๋ฒณ์ธ ๊ฒฝ์ฐ์๋ง ๋๋ฌธ์๋ก ๋ณํ์์ผ์ค๋ค. ์๋ฐ ์ฝ๋ import java.util.*; class Solution { public String solution(String s) { String answer = ""; s=s.toLowerCase(); StringBuilder sb = new StringBuilder(); for(int i=0;i
[JAVA] ํ๋ก๊ทธ๋๋จธ์ค ์คํ/ํ -ใ๋ค๋ฆฌ๋ฅผ ์ง๋๋ ํธ๋ญใ
import java.util.*; class Solution { public int solution(int bridge_length, int weight, int[] truck_weights) { Queue bridge = new LinkedList(); Queue truck = new LinkedList(); for(int i=0;i=totalWeight+waitingTruck)){ bridge.offer(truck.poll()); totalWeight+=waitingTruck; totalTruckNum++; //์ฐจ๊ฐ ๋ ๋ชป์ฌ๋ผ์ค๋ ๊ฒฝ์ฐ }else{ bridge.offer(0); } time++; } time+=bridge_length; return time; } } ๊ฒจ์ฐ๊ฒจ์ฐ ํผ์ ํ์ผ๋ก ํ์๋ค. ๋จผ..