개발 다이어리

문제

https://school.programmers.co.kr/learn/courses/30/lessons/131705

코드

class Solution {
	static int [] chkArr = new int[3];//삼총사
	static int [] intArr;
	static int answer = 0;
	
    public int solution(int[] number) {
        intArr = number;
        DFS(0,0);
        return answer;
    }
    
    void DFS(int lv, int s) {
		if(lv == 3) {
			int sum = 0;
			for(int x : chkArr) sum+=intArr[x];
			if(sum == 0) answer++;
		}else {
			for(int i =s; i< intArr.length;i++ ) {
				chkArr[lv] = i;
				DFS(lv+1, i+1);
			}
		}
    }
    
}

결과

테스트 1
입력값 〉	[-2, 3, 0, 2, -5]
기댓값 〉	2
실행 결과 〉	테스트를 통과하였습니다.
테스트 2
입력값 〉	[-3, -2, -1, 0, 1, 2, 3]
기댓값 〉	5
실행 결과 〉	테스트를 통과하였습니다.
테스트 3
입력값 〉	[-1, 1, -1, 1]
기댓값 〉	0
실행 결과 〉	테스트를 통과하였습니다.

경우의 수를 묻는 문제

경우의 수 마다 살짝 알고리즘을 더해 0이 되는지만 체크하면 된다.

문제

https://school.programmers.co.kr/learn/courses/30/lessons/1845

당신은 폰켓몬을 잡기 위한 오랜 여행 끝에, 홍 박사님의 연구실에 도착했습니다. 홍 박사님은 당신에게 자신의 연구실에 있는 총 N 마리의 폰켓몬 중에서 N/2마리를 가져가도 좋다고 했습니다.
홍 박사님 연구실의 폰켓몬은 종류에 따라 번호를 붙여 구분합니다. 따라서 같은 종류의 폰켓몬은 같은 번호를 가지고 있습니다. 예를 들어 연구실에 총 4마리의 폰켓몬이 있고, 각 폰켓몬의 종류 번호가 [3번, 1번, 2번, 3번]이라면 이는 3번 폰켓몬 두 마리, 1번 폰켓몬 한 마리, 2번 폰켓몬 한 마리가 있음을 나타냅니다. 이때, 4마리의 폰켓몬 중 2마리를 고르는 방법은 다음과 같이 6가지가 있습니다.

1. 첫 번째(3번), 두 번째(1번) 폰켓몬을 선택
2. 첫 번째(3번), 세 번째(2번) 폰켓몬을 선택
3. 첫 번째(3번), 네 번째(3번) 폰켓몬을 선택
4. 두 번째(1번), 세 번째(2번) 폰켓몬을 선택
5. 두 번째(1번), 네 번째(3번) 폰켓몬을 선택
6. 세 번째(2번), 네 번째(3번) 폰켓몬을 선택

이때, 첫 번째(3번) 폰켓몬과 네 번째(3번) 폰켓몬을 선택하는 방법은 한 종류(3번 폰켓몬 두 마리)의 폰켓몬만 가질 수 있지만, 다른 방법들은 모두 두 종류의 폰켓몬을 가질 수 있습니다. 따라서 위 예시에서 가질 수 있는 폰켓몬 종류 수의 최댓값은 2가 됩니다.
당신은 최대한 다양한 종류의 폰켓몬을 가지길 원하기 때문에, 최대한 많은 종류의 폰켓몬을 포함해서 N/2마리를 선택하려 합니다. N마리 폰켓몬의 종류 번호가 담긴 배열 nums가 매개변수로 주어질 때, N/2마리의 폰켓몬을 선택하는 방법 중, 가장 많은 종류의 폰켓몬을 선택하는 방법을 찾아, 그때의 폰켓몬 종류 번호의 개수를 return 하도록 solution 함수를 완성해주세요.

제한사항

• nums는 폰켓몬의 종류 번호가 담긴 1차원 배열입니다.
• nums의 길이(N)는 1 이상 10,000 이하의 자연수이며, 항상 짝수로 주어집니다.
• 폰켓몬의 종류 번호는 1 이상 200,000 이하의 자연수로 나타냅니다.
• 가장 많은 종류의 폰켓몬을 선택하는 방법이 여러 가지인 경우에도, 선택할 수 있는 폰켓몬 종류 개수의 최댓값 하나만 return 하면 됩니다.

입출력 예

입출력 예 설명

입출력 예 #1
문제의 예시와 같습니다.

입출력 예 #2
6마리의 폰켓몬이 있으므로, 3마리의 폰켓몬을 골라야 합니다.
가장 많은 종류의 폰켓몬을 고르기 위해서는 3번 폰켓몬 한 마리, 2번 폰켓몬 한 마리, 4번 폰켓몬 한 마리를 고르면 되며, 따라서 3을 return 합니다.

입출력 예 #3
6마리의 폰켓몬이 있으므로, 3마리의 폰켓몬을 골라야 합니다.
가장 많은 종류의 폰켓몬을 고르기 위해서는 3번 폰켓몬 한 마리와 2번 폰켓몬 두 마리를 고르거나, 혹은 3번 폰켓몬 두 마리와 2번 폰켓몬 한 마리를 고르면 됩니다. 따라서 최대 고를 수 있는 폰켓몬 종류의 수는 2입니다.

코드

import java.util.stream.IntStream;

class Solution {
	public int solution(int[] nums) {
		int length = IntStream.of(nums)
				 .distinct()
				 .toArray()
				 .length; 
		int choice = nums.length/2;
		return length < choice? length : choice ;
	}
}

결론

정확성  테스트
테스트 1 〉	통과 (3.09ms, 74.8MB)
테스트 2 〉	통과 (2.50ms, 75.1MB)
테스트 3 〉	통과 (3.45ms, 81.5MB)
테스트 4 〉	통과 (6.30ms, 67.1MB)
테스트 5 〉	통과 (2.99ms, 76.5MB)
테스트 6 〉	통과 (2.65ms, 77.7MB)
테스트 7 〉	통과 (2.64ms, 75.1MB)
테스트 8 〉	통과 (4.05ms, 79.3MB)
테스트 9 〉	통과 (3.74ms, 74.9MB)
테스트 10 〉	통과 (5.56ms, 79.5MB)
테스트 11 〉	통과 (7.85ms, 78.7MB)
테스트 12 〉	통과 (5.73ms, 79.4MB)
테스트 13 〉	통과 (5.91ms, 70.8MB)
테스트 14 〉	통과 (5.25ms, 77.4MB)
테스트 15 〉	통과 (32.34ms, 75.4MB)
테스트 16 〉	통과 (15.65ms, 82.3MB)
테스트 17 〉	통과 (13.68ms, 82.8MB)
테스트 18 〉	통과 (23.39ms, 81.8MB)
테스트 19 〉	통과 (18.95ms, 73.5MB)
테스트 20 〉	통과 (7.31ms, 86.1MB)

흠....왜 해시 분류에 이 문제가 있는지 아직 모르겠다.

문제

수많은 마라톤 선수들이 마라톤에 참여하였습니다. 단 한 명의 선수를 제외하고는 모든 선수가 마라톤을 완주하였습니다.

마라톤에 참여한 선수들의 이름이 담긴 배열 participant와 완주한 선수들의 이름이 담긴 배열 completion이 주어질 때, 완주하지 못한 선수의 이름을 return 하도록 solution 함수를 작성해주세요.

제한사항

• 마라톤 경기에 참여한 선수의 수는 1명 이상 100,000명 이하입니다.
• completion의 길이는 participant의 길이보다 1 작습니다.
• 참가자의 이름은 1개 이상 20개 이하의 알파벳 소문자로 이루어져 있습니다.
• 참가자 중에는 동명이인이 있을 수 있습니다.

입출력 예

입출력 예 설명

예제 #1
"leo"는 참여자 명단에는 있지만, 완주자 명단에는 없기 때문에 완주하지 못했습니다.

예제 #2
"vinko"는 참여자 명단에는 있지만, 완주자 명단에는 없기 때문에 완주하지 못했습니다.

예제 #3
"mislav"는 참여자 명단에는 두 명이 있지만, 완주자 명단에는 한 명밖에 없기 때문에 한명은 완주하지 못했습니다.

코드

import static java.util.stream.Collectors.*;

import java.util.*;
import java.util.stream.Stream;

class Solution {
    public String solution(String[] participant, String[] completion) {
    	// 이름 , 동명인 수
    	Map<String, Long> collect = Stream.<String>of(participant)
    			.collect(groupingBy( u->u , counting()));
    	// 완주자 제거
    	for(String str : completion) {
    		if(collect.containsKey(str)) {
    			collect.put(str, collect.get(str)-1 );
    		}
    	}
        return collect.entrySet().stream()
				.filter( entry -> entry.getValue()>0 )
				.map( entry -> entry.getKey() )
				.toArray( String[]::new )[0];
    }
}

결과

카테고리가 해시인 것을 보아 HashMap을 사용해야 할 것 같고,
개인적으로도 어차피 해시맵을 사용해 동명이인 수를 센 후 소거하면 될 것 같아서

그렇게 했다.

문제

숫자의 일부 자릿수가 영단어로 바뀌어졌거나, 혹은 바뀌지 않고 그대로인 문자열 s가 매개변수로 주어집니다. s가 의미하는 원래 숫자를 return 하도록 solution 함수를 완성해주세요.

숫자 /영단어

입출력 예

코드

import java.util.stream.Stream;

class Solution4 {
	//변환처리를 위한 배열, 순서 중요
	final static String[] INDEX_TO_WORD = 
		{ "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
	final static String NUM_STR = "0123456789";
	final static int WORD_LENGTH = 10;

	public static void main(String[] args) {
		Solution4 s = new Solution4();
		System.out.println(
		s.solution("2three45sixseven")
		);
	}
	
	public int solution(String s) {
		return Stream.of(s).mapToInt( arg ->{
			for(int i = 0 ; i < WORD_LENGTH ; i++) {
				arg = arg.replace(INDEX_TO_WORD[i] , String.valueOf(NUM_STR.charAt(i)) );
			}
			return Integer.valueOf(arg).intValue();
		}).sum();
	}
}

문제

지표 번호성격 유형

choices뜻

입출력 예

코드

package solution;
import java.util.HashMap;
import java.util.Map;

class Solution {
	//점수 저장 맵
	Map<Character, Integer> surveyMap = new HashMap<>();
	// 설문지에 맞는 점수배열, 앞에 아무숫자를 넣어 배열보정을 하면 나중에 -1 을 안해도된다.
	int[] scoreArr = {0,3,2,1,0,1,2,3}; 
	String[] survey;
	int[] choices;
	
	public static void main(String[] args) {
		Solution solution = new Solution();
		String[] survey = {"AN", "CF", "MJ", "RT", "NA"};
		int[] choices = {5, 3, 2, 7, 5};
		System.out.println(solution.solution(survey, choices));
	}
	
	public String solution(String[] survey, int[] choices) {
    	this.survey = survey;
    	this.choices = choices;
    	
    	//맵 초기화
    	for(char key : "RTCFJMAN".toCharArray()) {
    		surveyMap.put(key, 0);
    	}
    	
    	//검사지에 따른 점수 계산
    	for(int i=0; i<survey.length;i++) {
    		String tmp = survey[i];
    		char l = tmp.charAt(0);
    		char r = tmp.charAt(1);
			calculate(l,r,i);
    	}
    	
    	return result();
    }
	
	private String result() {
		StringBuilder sb =new StringBuilder();
		// 조건식 수정을 하면 동일할 경우 무엇을 리턴할지를 결정할 수 있다.
    	sb.append( sum('R','T')>=0?"R" : "T");
    	sb.append( sum('C','F')>=0?"C" : "F");
    	sb.append( sum('J','M')>=0?"J" : "M");
    	sb.append( sum('A','N')>=0?"A" : "N");
    	System.out.println(surveyMap);
        return sb.toString();
	}
	
	//점수를 계산한다.
	private void calculate(char l,char r, int i) {
		if(choices[i]<4) {
			accumulateValue(l, scoreArr[choices[i]]);
		}else {
			accumulateValue(r, scoreArr[choices[i]]);
		}
	}
	//계산된 결과에 따라 점수를 누산한다.
	private void accumulateValue(char key, int value) {
		surveyMap.put(key, surveyMap.get(key)+value);
	}
	
	private int sum(char l,char r) {
		return surveyMap.get(l) - surveyMap.get(r);
	}
	
}

결과

{A=1, R=0, C=1, T=3, F=0, J=0, M=2, N=1}
TCMA

choices 인자가 1~7 가 오는데, 그에 따른 점수는 3, 2,1, 0, 1, 2, 3 이다.

이를 보정하기 위해 choices 배열 크기에 맞는 점수 배열을 별도로 만들면, 좋다.

문제

https://school.programmers.co.kr/learn/courses/30/lessons/92334#

신입사원 무지는 게시판 불량 이용자를 신고하고 처리 결과를 메일로 발송하는 시스템을 개발하려 합니다. 무지가 개발하려는 시스템은 다음과 같습니다.

• 각 유저는 한 번에 한 명의 유저를 신고할 수 있습니다.
  • 신고 횟수에 제한은 없습니다. 서로 다른 유저를 계속해서 신고할 수 있습니다.
  • 한 유저를 여러 번 신고할 수도 있지만, 동일한 유저에 대한 신고 횟수는 1회로 처리됩니다.
• k번 이상 신고된 유저는 게시판 이용이 정지되며, 해당 유저를 신고한 모든 유저에게 정지 사실을 메일로 발송합니다.
  • 유저가 신고한 모든 내용을 취합하여 마지막에 한꺼번에 게시판 이용 정지를 시키면서 정지 메일을 발송합니다.

제한사항도 존재하는데 주로, 인자 유효성 부분이다.

그런데 제거해도 동작을 한다. 즉, 구현할 필요 없다.

코드

import static java.util.stream.Collectors.*;

import java.util.*;
import java.util.stream.Stream;


class Solution6 {
	public static void main(String[] args) {
		Solution6 s = new Solution6();
		int[] solution = s.solution(new String[] {"muzi", "frodo", "apeach", "neo"}
			, new String[] {"muzi frodo", "apeach frodo", "frodo neo", "muzi neo", "apeach muzi"}
			, 2);
		System.out.println(Arrays.toString(solution));
		
	}
	
	
	final int[] FAIL = new int[] {};
	//id_list 이용자 아이디 , 신고 정보 배열 report, 신고가정지로될 횟수
	public int[] solution(String[] id_list, String[] report, int k) {
		//알람을 몇번 받을지 저장할 맵, 순서가 중요하므로 Linked를 사용했다.
		Map<String, Integer> alramMap = new LinkedHashMap<>();
		//내가 누굴 신고했는지 저장할 맵, 순서가 중요하므로 Linked를 사용했다.
		Map<String, List<String>> reportedMap = new LinkedHashMap<>();
		
		//받은 인자에 맞게, 초기화
		Stream.<String>of(id_list).forEach(user -> {
			reportedMap.put(user, new ArrayList<String>());
			alramMap.put(user, 0);
		});
		
		//신고당한 횟수
		Stream.<String>of(report) // 신고 목록으로 스트림 생성
				.distinct() // 한 유저가 한 유저를 중복 신고한 경우 1번으로 처리
				.peek( _report -> System.out.println("신고 = "+_report ) )
				.map(_report ->{
					String[] users = _report.split(" ");
					//[0] 원고, [1] 피고
					reportedMap.get(users[0]).add(users[1]);//내 리스트에 피고 저장
					return users[1];})// 피고인으로 구성된 스트림
				.peek( badGuy -> System.out.println("신고 당한 유저 = "+badGuy +"\n" ))
				.collect(groupingBy(
							user->user, 
							LinkedHashMap<String, Integer>::new , 
							collectingAndThen(counting(), Long::intValue)))
				//내가 몇 번 신고 당했는지, 맵으로 리턴 key 내id, value 신고당한 횟수
				//신고당한 적 없다면 맵에 존재하지 않는다.
				.forEach((badUser, count)->{
					if(count>=k ) {// k 번 이상일 경우 계정 정지, 해당 사용자를 신고한 사람은 알림을 받는다.
						reportedMap.forEach( (user, badUsers)->{
							if(badUsers.contains(badUser)) {
								alramMap.put(user, alramMap.get(user)+1 );
							}
						});
					}
				});
		//맵을 int[]로 변환리턴
		return alramMap.values().stream().mapToInt(Integer::intValue).toArray();
	}
}

결과

신고 = muzi frodo
신고 당한 유저 = frodo

신고 = apeach frodo
신고 당한 유저 = frodo

신고 = frodo neo
신고 당한 유저 = neo

신고 = muzi neo
신고 당한 유저 = neo

신고 = apeach muzi
신고 당한 유저 = muzi

[2, 1, 1, 0]

입력 받은 순서대로 값을 리턴해야된다. 그래서 순서를 유지하는 맵을 사용했다.

문제

https://school.programmers.co.kr/learn/courses/30/lessons/12909

문제 설명

코드

import java.util.Stack;

class Solution {
	boolean solution(String s) {
		Stack<Character> stack = new Stack<Character>();
		try {
			for (char cha : s.toCharArray()) {
				if (cha == '(')
					stack.add(cha);
				else { //문자열은 '(' , ')' 밖에 없기 때문에 이 조건식
					stack.pop();
				}
			}
		} catch (Exception e) {
			return false; // 예외발생은 pop()에서 날 것 즉, 짝이 안맞는다.
		}
		return stack.empty() ? true : false;
	}
}

결과

정확성  테스트
테스트 1 〉	통과 (0.17ms, 76.7MB)
테스트 2 〉	통과 (0.20ms, 81.6MB)
테스트 3 〉	통과 (0.19ms, 79MB)
테스트 4 〉	통과 (0.22ms, 79MB)
테스트 5 〉	통과 (0.27ms, 76.4MB)
테스트 6 〉	통과 (0.14ms, 77.1MB)
테스트 7 〉	통과 (0.24ms, 78.2MB)
테스트 8 〉	통과 (0.20ms, 75.6MB)
테스트 9 〉	통과 (0.25ms, 72.8MB)
테스트 10 〉	통과 (0.25ms, 75MB)
테스트 11 〉	통과 (0.20ms, 72.4MB)
테스트 12 〉	통과 (0.22ms, 75.1MB)
테스트 13 〉	통과 (0.30ms, 75.5MB)
테스트 14 〉	통과 (0.24ms, 73.4MB)
테스트 15 〉	통과 (0.21ms, 75.4MB)
테스트 16 〉	통과 (0.22ms, 99.7MB)
테스트 17 〉	통과 (0.21ms, 74.8MB)
테스트 18 〉	통과 (0.25ms, 68MB)
효율성  테스트
테스트 1 〉	통과 (15.83ms, 53.8MB)
테스트 2 〉	통과 (14.89ms, 53.1MB)
채점 결과
정확성: 69.5
효율성: 30.5
합계: 100.0 / 100.0

예제에서 s 문자열은 '(', ')'만 존재한다고 했다. 

만약 여러 문자열이 섞여있다면 else if로 변경만 하면 될 것이다.

문제

https://school.programmers.co.kr/learn/courses/30/lessons/64061

이 차원 배열로 이루어진 인형 뽑기 기계에서 인형을 뽑기

뽑은 인형은 내 보관함에 저장되며, 저장된 인형이 2 연속 같다면 제거한다.

해당 위치에 인형이 없다면 아무일도 하지 않는다.

제거된 인형 수를 리턴하도록 구현

[제한사항]

• board 배열은 2차원 배열로 크기는 "5 x 5" 이상 "30 x 30" 이하입니다.
• board의 각 칸에는 0 이상 100 이하인 정수가 담겨있습니다.
  • 0은 빈 칸을 나타냅니다.
  • 1 ~ 100의 각 숫자는 각기 다른 인형의 모양을 의미하며 같은 숫자는 같은 모양의 인형을 나타냅니다.
• moves 배열의 크기는 1 이상 1,000 이하입니다.
• moves 배열 각 원소들의 값은 1 이상이며 board 배열의 가로 크기 이하인 자연수입니다.

코드

import java.util.Deque;
import java.util.LinkedList;
//크레인 인형뽑기 게임
class Solution7 {
	/*편의상 변수로 둔 것*/
	static Deque<Integer> deque = new LinkedList<>();
	static int count = 0;
	static int move = 0;
	static int[][] board = new int[][] {{0,0,0,0,0}
										,{0,0,1,0,3}
										,{0,2,5,0,1}
										,{4,2,4,4,2}
										,{3,5,1,3,1}};
	static int[] moves = new int[] {1,5,3,5,1,2,1,4};
	
	/* 제출 시 콘솔 출력 부분 제거 or 주석 */
	public static void main(String[] args) {
		Solution7 s = new Solution7();
		s.solution(board, moves);
		
		System.out.println("제거된 인형 "+count);
	}
	
	
	public int solution(int[][] board, int[] moves) {
		
		print();
		for(int i=0;i<moves.length;i++) {
			System.out.println("인형뽑기 [" + moves[i] +"] 위치 " );
			get(moves[i]-1 );  // 인덱스 값 보정을 위해 -1
			System.out.println();
			print();
		}
		return count;
	}
	
	// 원하는 인형을 집는다.
	public void get(Integer select) {
		for (int hei = 0; hei< board.length ; hei++) {
			int value = board[hei][select] ;
			System.out.println("인형 찾기... board["+hei+"]["+select+"]"  + (value != 0 ? " 인형 찾음!!" : " 인형 없음"));
			if(value != 0) {
				board[hei][select] = 0;
				add(value);
				return;
			}
			
		}
	}
	
	// 마지막으로 저장한 값과 저장할 값이 같다면 저장하지 않는다.
	public boolean add(Integer num) {
		if(deque.size()!=0 && deque.peekLast().intValue() ==  num.intValue()) {
			System.out.println("제거 = "+deque.peekLast()+","+num);
			deque.pollLast(); // 요소를 꺼냄과 동시에 제거를 해준다.
			count += 2; // 제거한 수 만큼 증가시킨다.
			System.out.println("인형보관함 " + deque);
			return false;
		}
		deque.add(num);
		System.out.println("인형보관함 " + deque);
		return true;
	}
	
	/*출력용 메서드 */
	private void print() {
		for(int i=0;i<board.length;i++) {
			System.out.print("[");
			for(int j=0;j<board[i].length;j++) {
				System.out.print(board[i][j] +( j== board[i].length-1? "" : ", "));
			}
			System.out.println("]");
		}
	}
}

결과

[0, 0, 0, 0, 0]
[0, 0, 1, 0, 3]
[0, 2, 5, 0, 1]
[4, 2, 4, 4, 2]
[3, 5, 1, 3, 1]
인형뽑기 [1] 위치 
인형 찾기... board[0][0] 인형 없음
인형 찾기... board[1][0] 인형 없음
인형 찾기... board[2][0] 인형 없음
인형 찾기... board[3][0] 인형 찾음!!
인형보관함 [4]

[0, 0, 0, 0, 0]
[0, 0, 1, 0, 3]
[0, 2, 5, 0, 1]
[0, 2, 4, 4, 2]
[3, 5, 1, 3, 1]
인형뽑기 [5] 위치 
인형 찾기... board[0][4] 인형 없음
인형 찾기... board[1][4] 인형 찾음!!
인형보관함 [4, 3]

[0, 0, 0, 0, 0]
[0, 0, 1, 0, 0]
[0, 2, 5, 0, 1]
[0, 2, 4, 4, 2]
[3, 5, 1, 3, 1]
인형뽑기 [3] 위치 
인형 찾기... board[0][2] 인형 없음
인형 찾기... board[1][2] 인형 찾음!!
인형보관함 [4, 3, 1]

[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 2, 5, 0, 1]
[0, 2, 4, 4, 2]
[3, 5, 1, 3, 1]
인형뽑기 [5] 위치 
인형 찾기... board[0][4] 인형 없음
인형 찾기... board[1][4] 인형 없음
인형 찾기... board[2][4] 인형 찾음!!
제거 = 1,1
인형보관함 [4, 3]

[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 2, 5, 0, 0]
[0, 2, 4, 4, 2]
[3, 5, 1, 3, 1]
인형뽑기 [1] 위치 
인형 찾기... board[0][0] 인형 없음
인형 찾기... board[1][0] 인형 없음
인형 찾기... board[2][0] 인형 없음
인형 찾기... board[3][0] 인형 없음
인형 찾기... board[4][0] 인형 찾음!!
제거 = 3,3
인형보관함 [4]

[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 2, 5, 0, 0]
[0, 2, 4, 4, 2]
[0, 5, 1, 3, 1]
인형뽑기 [2] 위치 
인형 찾기... board[0][1] 인형 없음
인형 찾기... board[1][1] 인형 없음
인형 찾기... board[2][1] 인형 찾음!!
인형보관함 [4, 2]

[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 5, 0, 0]
[0, 2, 4, 4, 2]
[0, 5, 1, 3, 1]
인형뽑기 [1] 위치 
인형 찾기... board[0][0] 인형 없음
인형 찾기... board[1][0] 인형 없음
인형 찾기... board[2][0] 인형 없음
인형 찾기... board[3][0] 인형 없음
인형 찾기... board[4][0] 인형 없음

[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 5, 0, 0]
[0, 2, 4, 4, 2]
[0, 5, 1, 3, 1]
인형뽑기 [4] 위치 
인형 찾기... board[0][3] 인형 없음
인형 찾기... board[1][3] 인형 없음
인형 찾기... board[2][3] 인형 없음
인형 찾기... board[3][3] 인형 찾음!!
인형보관함 [4, 2, 4]

[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 5, 0, 0]
[0, 2, 4, 0, 2]
[0, 5, 1, 3, 1]
제거된 인형 4

문제

https://school.programmers.co.kr/learn/courses/30/lessons/72410

1단계 new_id의 모든 대문자를 대응되는 소문자로 치환합니다.
2단계 new_id에서 알파벳 소문자, 숫자, 빼기(-), 밑줄(_), 마침표(.)를 제외한 모든 문자를 제거합니다.
3단계 new_id에서 마침표(.)가 2번 이상 연속된 부분을 하나의 마침표(.)로 치환합니다.
4단계 new_id에서 마침표(.)가 처음이나 끝에 위치한다면 제거합니다.
5단계 new_id가 빈 문자열이라면, new_id에 "a"를 대입합니다.
6단계 new_id의 길이가 16자 이상이면, new_id의 첫 15개의 문자를 제외한 나머지 문자들을 모두 제거합니다.
     만약 제거 후 마침표(.)가 new_id의 끝에 위치한다면 끝에 위치한 마침표(.) 문자를 제거합니다.
7단계 new_id의 길이가 2자 이하라면, new_id의 마지막 문자를 new_id의 길이가 3이 될 때까지 반복해서 끝에 붙입니다.

[입출력 예]

nonew_idresult

코드

class Solution {
    public String solution(String new_id) {
    	new_id = new_id.toLowerCase(); //1단계
    	new_id = new_id.replaceAll("[^a-z0-9\\-_\\.]", "");//2단계
    	new_id = new_id.replaceAll("\\.{2,}", ".");//3단계
    	new_id = new_id.replaceAll("^\\.", "");//3단계
    	new_id = new_id.replaceAll("\\.$", "");//4단계
    	if(new_id.isEmpty()) new_id="a"; //5단계
    	if(new_id.length()>15) new_id = String.copyValueOf(new_id.toCharArray(), 0, 15);//6단계
    	new_id = new_id.replaceAll("\\.$", "");
    	for(;new_id.length()<3;) new_id= new_id.concat(new_id.charAt(new_id.length()-1)+"" );//7단계
        return new_id;
    }
}

결론

정규식 기초를 보는 문제 같다. 

내가 생각하는 이 문제에서 바라는 정규식 수준을 키워드로 나열하면,

(반복) 수량자,  콤마(.)의 활용, 문자 클래스 문법([ ] , 이 대괄호 속 문법은 약간 다름), 이스케이프(\), 앵커

이 정도 같다.

개인적으로는 이정도만 알고, 필요할 때 더 공부하는 것이 맞는 것 같다. 

자바에서 정규식은 이스케이프 문제를 이스케이프화하는 부분이 실수하기 좋은 부분 같다. 

정규식의 예약문자를 이스케이프 하기 위한 "\"는 자바에서도 예약 문자라 이스케이프 해줘야 한다.

"\" => "\\"

System.out.println("[^a-z0-9\\-_\\.]");
System.out.println("\\.{2,}");
System.out.println("^\\.");
System.out.println("\\.$");
System.out.println("\\.$");
---------------------------------------------
[^a-z0-9\-_\.]
\.{2,}
^\.
\.$
\.$

실질적으로 자바가 먼저 입력받은 문자열을 파싱한 후, 아래 출력 값을 정규식 인자로 사용할 것이다.

이 부분을 조금 편하게 하는 제 방식을 다음과 같다.

//오류 무시하고 작성
System.out.println("[^a-z0-9\-_\.]");
//빈공간에!!
System.out.println("");
// [^a-z0-9\-_\.] 를 복붙, 이클립스가 자동으로'\'=>'\\' 치환해줌
System.out.println("[^a-z0-9\\-_\\.]");

--------------------------------------------------
위 결과를 ctrl -H 로 일괄 치환하면, 위험할 수 있는 이유
//오류 무시하고 작성
System.out.println("[^a-z0-9\\-_\\.]");
//빈공간에!!
System.out.println("");
// [^a-z0-9\\-_\\.] 를 복붙
System.out.println("[^a-z0-9\\\\-_\\\\.]"); 다른 부분은 이렇게 될 수도 있다

문제

import java.util.HashMap;
import java.util.Map;

class Solution {
	Map<Character, Integer> surveyMap = new HashMap<Character, Integer>();
	int[] scoreArr = {3,2,1,0,1,2,3};
	String[] survey;
	int[] choices;
	
	public String solution(String[] survey, int[] choices) {
    	this.survey = survey;
    	this.choices = choices;
    	
    	for(char key : "RTCFJMAN".toCharArray()) {
    		surveyMap.put(key, 0);
    	}
    	
    	for(int i=0; i<survey.length;i++) {
    		String tmp = survey[i];
    		char l = tmp.charAt(0);
    		char r = tmp.charAt(1);
			calculate(l,r,i);
    	}
    	
    	StringBuilder sb =new StringBuilder();
    	sb.append( sum('R','T')>=0?"R" : "T");
    	sb.append( sum('C','F')>=0?"C" : "F");
    	sb.append( sum('J','M')>=0?"J" : "M");
    	sb.append( sum('A','N')>=0?"A" : "N");

        return sb.toString();
    }
	private int sum(char l,char r) {
		return surveyMap.get(l) - surveyMap.get(r);
	}
	private void accumulateValue(char key, int value) {
		surveyMap.put(key, surveyMap.get(key)+value);
	}
	private void calculate(char l,char r, int i) {
		if(choices[i]<4) {
			accumulateValue(l, scoreArr[choices[i]-1]);
		}else {
			accumulateValue(r, scoreArr[choices[i]-1]);
		}
	}
}