개발 다이어리

문제

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/42579

문제 설명

코드

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

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

class Solution {
	static int i = 0;

	public int[] solution(String[] genres, int[] plays) {
		return IntStream.range(0, genres.length) // intStream
				        .mapToObj(i-> new TopGenrePlay(i, genres[i], plays[i])) // 기본형에서 참조형으로
				        .collect(groupingBy( TopGenrePlay::getGenre))			 // key는 genres[i] 객체 그대로 Map<String, List<TopGenrePlay>>
				        .entrySet().stream()	//   Stream<Entry<String, List<TopGenrePlay>>>
				        .sorted( (a,b)-> { // 스트림 안에서 총 Play집계 값으로 내림차순
					       	 int sum1 = a.getValue().stream().mapToInt(TopGenrePlay::getPlay).sum();
					       	 int sum2 = b.getValue().stream().mapToInt(TopGenrePlay::getPlay).sum();
					       	 return Integer.compare(sum2, sum1);}) //내림차순  
				        .map( entry -> { //<Entry<String, List<TopGenrePlay>>> 
					       	 List tgpList = entry.getValue().stream().sorted()//정렬은 객체에 구현된 Comparable에 의존한다.
							       			 		                 .limit(2)//정렬된 결과에서 2개만 가져온다.
							       			 		                 .map( TopGenrePlay::getId ).collect(toList());//식별값만 필요하다.
					       	 entry.setValue(tgpList);
					       	 return entry; } )
				        .flatMap( entry-> Stream.of(entry.getValue().toArray(new Integer[] {}))) // 하나의 스트림으로 만든다.
				        .mapToInt( Integer::intValue ) //기본형 스트림으로 IntStream
				        .toArray()
				        ;
	}

	public static void main(String[] args) {
		Solution s = new Solution();
		System.out.println(Arrays.toString(s.solution(
				new String[] { "classic", "pop", "classic", "classic", "pop", "trot", "trot", "trot", "pop" },
				new int[] { 1000, 600, 2000, 1000, 2500, 6000, 200, 200, 600 })));

	}

	class TopGenrePlay implements Comparable<TopGenrePlay> {
		int id;
		String genre;
		int play;

		public int getId() {
			return id;
		}

		public void setId(int id) {
			this.id = id;
		}

		public String getGenre() {
			return genre;
		}

		public void setGenre(String genre) {
			this.genre = genre;
		}

		public int getPlay() {
			return play;
		}

		public void setPlay(int play) {
			this.play = play;
		}

		public TopGenrePlay(int id, String genre, int play) {
			super();
			this.id = id;
			this.genre = genre;
			this.play = play;
		}
		@Override
		public String toString() {
			return "[id="+ id + ", genre=" + genre + ", play=" + play + "]";
		}
		@Override
		public int compareTo(TopGenrePlay o) {
			int result = Integer.compare(o.play, this.play);
			if (result == 0) {
				return Integer.compare(this.id, o.id);
			}
			return result;
		}
	}

}

결과

정확성  테스트
테스트 1 〉	통과 (17.71ms, 82.3MB)
테스트 2 〉	통과 (13.47ms, 77.6MB)
테스트 3 〉	통과 (15.14ms, 81.7MB)
테스트 4 〉	통과 (15.90ms, 73.1MB)
테스트 5 〉	통과 (9.80ms, 81.5MB)
테스트 6 〉	통과 (15.30ms, 73.7MB)
테스트 7 〉	통과 (10.73ms, 72.7MB)
테스트 8 〉	통과 (9.44ms, 73.7MB)
테스트 9 〉	통과 (9.91ms, 73.8MB)
테스트 10 〉	통과 (16.23ms, 80.8MB)
테스트 11 〉	통과 (8.91ms, 75MB)
테스트 12 〉	통과 (8.83ms, 75.1MB)
테스트 13 〉	통과 (14.77ms, 81.3MB)
테스트 14 〉	통과 (10.05ms, 78.5MB)
테스트 15 〉	통과 (8.19ms, 75.4MB)

퇴근하고 이틀 동안 계속 붙잡았다... 컬렉션으로만 해결하려 했던게 오히려 나에겐 독이였다.

될듯..?말듯...

그러다 문득, 내가 자바를 하는데 너무 함수형으로 생각한 게 아닌가 라는 생각이 들었다.

갑자기 Class를 활용할 생각을 안하고 컬렉션만 쓰려했는지...참...

그래도 이 교훈은 오래 남을 듯 하다.

누군가 봐서 조금이라도 도움이 됐으면하는 마음으로 중간중간에 데이터 형을 입력했다.

위 코드의 개략적인 구도는 play, id 순 정렬은 객체의 Comparable 구현에 의존한다.

이 정렬 전에 장르별 정렬은 스트림을 사용해 장르별 그룹화 후 

내부 List 반복으로 총 집계를 내어 정렬했다.

필요한 정렬정보는 모두 모였으므로, 데이터 가공으로 id 배열을 만들어 리턴했다.

문제

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]);
		}
	}
}