초딩코보 루피

문제는 이러하다.

먼저, 수열은 1, 2, 3만 사용하므로 배열 list에 이를 저장한다.

답은 무조건 9보다 작기 때문에 answer을 9 로 설정해놓는다!

DFS를 돌면서, 현재 수열에서 마지막 두 개의 인접한 부분 수열을 비교하고

만약 인접한 부분 수열이 동일하면 해당 수열은 나쁜 수열로 간주,

그렇지 않으면 탐색을 계속 진행하여 수열을 확장하기!

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.*;
import java.util.*;
 
 
public class Main {
 
    static int n;
    static String[] list = {"1", "2", "3"};
    static String answer = "9";
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(br.readLine());
 
 
        dfs(0, "");
 
        System.out.println(answer);
    }
 
    private static void dfs(int index, String origin) {
        if (index == n) {
            System.out.println(origin);
            System.exit(0);
        }
 
        for (int i = 0; i <= 2; i++) {
            if (check(origin+list[i])) {
                dfs(index + 1, origin + list[i]);
            }
        }
    }
 
    private static boolean check(String checkStr) {
        int length = checkStr.length() / 2;
 
        for (int i = 1; i <= length; i++) {
            if (checkStr.substring(checkStr.length() - i).equals(checkStr.substring(checkStr.length() - 2 * i, checkStr.length() - i))) {
                return false;
            }
        }
 
        return true;
    }
}

문제는 다음과 같다.

이 문제에서는 거리를 맨해튼거리로 계산하기 때문에 조금 더 난이도가 쉬운편!

각 플랫폼에서 맨해튼거리로 L 보다 같거나 작은 거리 내 동물들을 다 잡을 수 있다고 가정했을 때

잡을 수 있는 모든 동물의 수를 구하는 문제이다!

플랫폼의 수를 M,  동물의 수를 N, 거리를 L이라고 둔다.

플랫폼의 y좌표는 어짜피 0이므로, 플랫폼의 x좌표를 저장할 배열을 만들어준다. 값을 입력받고 오름차순 정렬해준다.

Long[] plate = new Long[M];
...
Arrays.sort(plate);

이렇게 된다면 plate[0] 에는 x축에 가장 가까운 사대가, plate[plate.length-1]에는 x축에서 가장 먼 사대가 되는 것이다.

동물의 x, y좌표를 입력받으면서

plate를 기준으로 start값과 end 값을 잡아준다.

가장 초기에는 start는 0, end는 plate.length-1로 둔다.

mid값은 (start + end)/2 이다.

이분탐색을 돌며 plate[mid]에서 해당 동물의 거리를 구하고, 그 값을 기준으로

1. L과 같거나 작으면 답을 추가한다.

2. L보다 크다면 ...

// 모든 사대는 y의 값이 0이다. 따라서 맨해튼 거리를 구할 때 mid값이 바뀌어도 x좌표끼리의 값만 바뀌지, y 값은 항상 일정하다.

    2-1. plate[mid] - x가 0보다 크다면, L과 같거나 작게 만드려면 plate[mid] 의 값이 줄어들어야된다. 따라서 mid값을 줄이기 위해 end값을 mid - 1 로 바꾼다.

    2-2. plate[mid] - x가 0보다 작다면, plate[mid] 값은 항상 양수기때문에 값이 커져야된다. 따라서 start값을 mid + 1로 바꾼다.

이렇게 이분탐색을 시행하면 문제가 풀린다!

이분탐색을 들어가기 전

동물의 y값이 L보다 이미 큰 상태라면 -> 모든 동물이 다 포함될 수 없으므로 이분탐색 하지말고 바로넘긴다!

이거까지 하면 실행속도가 더 줄어든다.

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(bf.readLine());
        int M = Integer.parseInt(st.nextToken()),
        N = Integer.parseInt(st.nextToken()),
        L = Integer.parseInt(st.nextToken());

        Long[] plate = new Long[M];
        st = new StringTokenizer(bf.readLine());
        for(int i=0;i<M;i++) {
            plate[i] = Long.parseLong(st.nextToken());
        }
        Arrays.sort(plate);

        int ans = 0;
        for(int i=0;i<N;i++) {
            st = new StringTokenizer(bf.readLine());
            Long x = Long.parseLong(st.nextToken()), y = Long.parseLong(st.nextToken());
            int start = 0, end = M-1;
            if(y > L) continue;
            while(start <= end) {
                int mid = (start+end)/2;
                Long target = plate[mid] - x;
                Long distance = Math.abs(target) + y;

                if(distance <= L) {
                    ans++;
                    break;
                } else if(target > 0) {
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            }

        }

        System.out.println(ans);

    }
}

문제 캡처

소스 코드

import java.util.*;
import java.io.*;

public class 최소편집_15483 {
	public static void main(String[] args) throws Exception {
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		String A = bf.readLine();
		String B = bf.readLine();
		int[][] dp = new int[A.length()+1][B.length()+1];

		for (int i = 0; i < dp.length; i++) {
			dp[i][0] = i;
		}
		for (int i = 0; i < dp[0].length; i++) {
			dp[0][i] = i;
		}
		
		for (int i = 1; i < A.length()+1; i++) {
			for (int j = 1; j < B.length()+1; j++) {
				if(A.charAt(i-1) == B.charAt(j-1)) {
					dp[i][j] = dp[i-1][j-1];
				}else {
					dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]),dp[i-1][j-1])+1;					
				}
			}
		}
		
		System.out.println(dp[A.length()][B.length()]);

	}
}	

Comment…💭

• 전형적인 DP문제,,각 자리에 알파벳을 비교하며 같으면 직전 알파벳 비교한것과 같은값으로, 아니라면 추가(dp[i][j-1]), 삭제(dp[i-1][j]), 교체(dp[i-1][j-1]) 한 값 중 가장 작은 값 선택 후 횟수 +1 하기!

문제는 다음과 같다.

숫자 N개를 입력받아, 숫자끼리 비교하며 0~9 중 같은 숫자가 쓰이는 경우가 있다면 ans++ 해주면 된다.

앗... 자리수가 0~9까지로 단 10자리?!

둘 다 있는지 비교?!

이것은...

비트마스킹.

과거의 나는 비트마스킹을 정말 싫어하였지만

이제는 그것도 다 옛말.

나는 비트의 몸을 맡기는 비트마스커 뤂시우가 되었다.

N개의 수를 입력받을 때, 각각의 자리수로 for문을 한 번 더 돌려, 해당하는 수의 위치의 비트를 1로 바꿔준다.

예를 들어, 비트를 바꾸기 전

int number = 0;

으로 설정해준다.

해당 number을 이진수로 표현하자면

일 것이다.

만약 입력받은 수가 32라면

String temp = "32";

temp.length()로 for문을 돌렸을 때, 처음 temp.charAt(POINT) 은 '3'일 것이다.

그렇다면, 우리가 number에 적용해야 하는 숫자는

일 것이다.

따라서 1을 왼쪽으로 3번 shift연산 후,

 number |= temp.charAt(j) - '0';

number와 이를 합치면 된다!

2도 이와같이 진행하면, 최종적으로 number은

1100 이렇게 될 것이다.

마찬가지로, 282도 이와같이 나타낼경우 

100000100 이렇게 될 것이다. 마지막 2를 적용할 때, 이미 2가 1이 있지만 합집합 연산하면 그대로 1이 적용된다.

이 숫자들을 HashMap nums에 갯수와 함께 넣는다!

그 후, HashMap을 돌면서 같은 nums에 대해 1개 이상일 경우 ans를 업데이트 해준다.

        for (Map.Entry<Integer, Integer> entry:nums.entrySet()) {
            int num = entry.getKey();
            int cnt = entry.getValue();
            
            ans += (long)cnt*(cnt-1)/2; //cnt 중 순서 없이 2개 뽑기

이 num을 다른 HashMap내 num 들과 비교해아하는데, 중복 방지를 위해 현재의 num보다 큰 애들과 비교해준다.

비교하는 수를 num = 32, num2 = 282라고 가정해보자.

두 수는 "2" 라는 공통된 수를 갖고있다. 이는 비트마스킹 된 값으로 쉽게 찾을 수 있는데

이것은 32의 nums 값이고,

이것은 282의 nums 값이다.

이 둘을 교집합연산 (&) 하면

공통으로 갖는 2만 1이되고, 나머지는 0이 됨을 알 수 있다.

따라서 num&num2 연산을 했을 시 0이 아니라면, 공통된 수를 갖고 있는 것이다!

이때는 num이 가지고있는 갯수 중 하나와, num2가 가지고 있는 갯수 중 하나를 뽑아야되기 때문에 nums.get(num) * nums.get(num2) 로 ans를 업데이트한다.

            for (int num2 : nums.keySet()) {
                if(num >= num2) continue; //num보다 작은 경우 continue처리
                if((num & num2) != 0) {
                    ans += (long) cnt*nums.get(num2);
                }
            }

이 과정을 모두 끝낸다면

맞으면 된다!

전체 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class 수업시간에교수님몰래교실을나간상근이_2825 {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(bf.readLine());
        Map<Integer, Integer> nums = new HashMap<>();

        for(int i = 0; i < N; i++) {
            String temp = bf.readLine();
            int number = 0;
            for(int j = 0; j < temp.length(); j++) {
                number |= 1 << (temp.charAt(j) - '0');
            }
            nums.put(number, nums.getOrDefault(number, 0) + 1);
        }

        long ans = 0;
        for (Map.Entry<Integer, Integer> entry:nums.entrySet()) {
            int num = entry.getKey();
            int cnt = entry.getValue();
            
            ans += (long)cnt*(cnt-1)/2;
            
            for (int num2 : nums.keySet()) {
                if(num >= num2) continue;
                if((num & num2) != 0) {
                    ans += (long) cnt*nums.get(num2);
                }
            }
        }
        System.out.println(ans);
    }
}

문제는 다음과 같다핑

문제에 대하여 간략히 설명을 해보자면,

1. 각 집은 빨강, 초록, 파랑 중 하나로 칠해야 한다.

2. 옆집과 같은 색으로 칠할 수 없다.

3. 첫 번째 집과 마지막 집도 서로 다른 색이어야 한다.

의 조건을 만족하는, 색 최소비용을 더해서 구하면 된다.

import java.io.*;
import java.util.StringTokenizer;


public class RGB거리2_17404 {

    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(bf.readLine());
        int[][] arr = new int[n + 1][3], dp = new int[n + 1][3];
        StringTokenizer st = null;

        for(int i = 1 ; i <= n; i++){
            st = new StringTokenizer(bf.readLine());
            for(int j = 0 ; j < 3; j++){
                arr[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        int ans = 10000001;
        for(int k = 0; k < 3; k++) {
            for(int i = 0 ; i < 3; i++) {
                if(i == k) {
                    dp[1][i] = arr[1][i];
                }
                else {
                    dp[1][i] = ans;
                }
            }

            for (int i = 2; i <= n; i++) {
                dp[i][0] = Math.min(dp[i - 1][1], dp[i - 1][2]) + arr[i][0];
                dp[i][1] = Math.min(dp[i - 1][0], dp[i - 1][2]) + arr[i][1];
                dp[i][2] = Math.min(dp[i - 1][0], dp[i - 1][1]) + arr[i][2];
            }
            
            for(int i = 0 ; i < 3; i++) {
                if(i != k) {
                    ans = Math.min(ans, dp[n][i]);
                }
            }
        }
        System.out.println(ans);
    }
}

전형적인 dp 문제!

먼저 arr 배열로 색 별 가격을 쭉 받은다음, dp 배열로 집을 빨강, 초록, 파랑으로 칠하는 세 가지 경우를 각각 고려한다.

그 후 dp 배열을 만들어 dp[i][j]를 i번째 집을 색깔 j로 칠할 때의 최소 비용으로 둔다.

dp[i][j] = min(dp[i-1][k]) + arr[i][j]

마지막 집은 첫 번째 집과 같은 색이 될 수 없으므로, 첫 번째 집의 색깔과 다른 색깔 중 최소 비용을 선택한다.

                if(i != k) {
                    ans = Math.min(ans, dp[n][i]);
                }

문제는 다음과 같다.

처음 보고 배낭문제 비슷하게 풀면 되는줄 알았으나..

자세히 보니 다르다! 무조건 가방보다 작거나 같은 무게 중 비싼 애들만 담으면 되는 비교적 간단한(이게 왜 골드2..?) 문제!

package baekjoon;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class 보석도둑_1202 {
    static class Jewel {
        int M, V;

        Jewel(int M, int V) {
            this.M = M;
            this.V = V;
        }
    }
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(bf.readLine());
        PriorityQueue<Jewel> jewels = new PriorityQueue<>(new Comparator<Jewel>() {

            @Override
            public int compare(Jewel o1, Jewel o2) {
                return Integer.compare(o1.M, o2.M);
            }
            
        });
        int N = Integer.parseInt(st.nextToken()), K = Integer.parseInt(st.nextToken());
        for(int i=0;i<N;i++) {
            st = new StringTokenizer(bf.readLine());
            jewels.offer(new Jewel(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken())));
        }

        PriorityQueue<Integer> bags = new PriorityQueue<>();
        for(int i=0;i<K;i++) {
            bags.offer(Integer.parseInt(bf.readLine()));
        }

        long ans = 0;
        PriorityQueue<Jewel> tempJewels = new PriorityQueue<>(new Comparator<Jewel>() {

            @Override
            public int compare(Jewel o1, Jewel o2) {
                if(o1.V == o2.V) {
                    return o1.M - o2.M;
                }
                return o2.V - o1.V;
            }
            
        });
        while(!bags.isEmpty()) {
            int bag = bags.poll();
            while(!jewels.isEmpty() && jewels.peek().M <= bag) {
                tempJewels.offer(jewels.poll());
            }
            if(tempJewels.isEmpty()) {
                continue;
            }
            ans += tempJewels.poll().V;
            System.out.println(ans);
        }
        System.out.println(ans);
    }
}

저음 보석을 받을 때 Jewel class를 만들어 pq안에 담아준다.

이때의 pq는 무게 M이 낮은 순으로 정렬되게!! (나는 값어치까지 비교하여 넣어주긴 했는데 이건 없어도 된다.)

이후 가방을 받고, 가방은 무게만 필요하니 class없이 Integer 값으로!

얘도 다른 pq에 넣어주는데, 무게가 낮은 애부터 정렬되게!! -> 정렬 조건 설정해줄 필요가 없다.

이후의 풀이를 단계별로 설명하자면,

1. bags에서 bag 한 개 poll 해온다.

2. bag 보다 작거나 같은 무게를 가진 jewel를 jewels에서 poll 한다.

3. poll한 jewel들을 tempJewels의 priority queue에 넣어준다.

* tempJewels는 값 V가 높은 순으로 정렬되게 Comparator로 정의해준다.(나는 무게까지 비교했는데 이거도 없어도 된다.)

4. tempJewels에서 poll 한 값을 정답으로 return할 값에 더해준다.

이 4가지의 단계를 bags에 남은 Integer가 없을 때까지 반복하면 된다!

그럼 정답이 뾰로롱~

곧있으면 플레 간다 야호!!

문제는 다음과 같다.

풀이는 비교적 간단하다.

먼저, 이중for문을 돌면서 기준 단어와 대상 단어의 접두사 길이를 구한다.이후 새로 구한 길이가 더 클 경우에만 업데이트를 한다.

package baekjoon;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class 비슷한단어_2179 {

    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(bf.readLine());

        char[][] inputs = new char[N][];

        for(int i=0;i<N;i++) {
            inputs[i] = bf.readLine().toCharArray();
        }

        int idx1 = -1, idx2 = -1, count = -1;

        for(int i=0;i<N-1;i++) {

            for(int j=i+1;j<N;j++) {
                if(inputs[i][0] != inputs[j][0]) continue;
                int cnt = 0;
                while(cnt<inputs[i].length && cnt < inputs[j].length && inputs[i][cnt] == inputs[j][cnt]) {
                    cnt++;
                }
                if(cnt > count) {
                    count = cnt;
                    idx1 = i; idx2 = j;
                }
            }
        }

        for(int i=0;i<inputs[idx1].length;i++) {
            System.out.print(inputs[idx1][i]);
        }
        System.out.println();
        for(int i=0;i<inputs[idx2].length;i++) {
            System.out.print(inputs[idx2][i]);
        }
    }
}

주인장은 요즘 리팩토링에 빠졌습니다.

아침에 일어나서 자기 전까지 하루종일 리팩토링만 하고 있는 것 같아요(거짓말입니다)

제 코드 및 다른 팀원들의 코드를 내맘대로 리뷰하는 중 여러 Handler를 사용하면 코드가 더 깔끔하고 유지보수가 편해질 것 같아 상의도 없이 만들고 PR날린 그것,

ErrorHandler, Validator

기존 코드를 봅시다

@Service
@RequiredArgsConstructor
public class BattleServiceImpl implements BattleService {

	//생략

	@Override
	public void registBattle(BattleInviteRequest battleInviteRequest, User user) {
    
    	//생략
    
    	if (battleInviteRequest.getOppositeUserId() == user.getId()) {
			throw new IllegalArgumentException("Not valid user");
		}
		if (battleInviteRequest.getTime() <= 0) {
			throw new RuntimeException("Wrong time setting");
		}

아...

진짜 아... 싶죠? 분명 던지는 에러들이 서버 상 오류가아닌 비지니스로직 적 이루어질 수 있는 에러인데, 저렇게 서비스단에 2~3줄 심지어 if문으로 메서드 안에 넣으면...... 나중에 혹시라도 수정하게되거나 로직을 변경해야 되는 일이 생겼을 시 굉장히 귀찮아지겠죠?ㅎㅎ....

여기서 제가 생각해낸 방법은

1. 체크해야되는 조건들을 하나의 파일로 묶는다.

2. 오류 결과들을 하나의 파일에 정리한다

3. 던진다!

의 과정입니다.

먼저, 저 말도안되는 Not a valid user과 Wrong time setting을 과감히 지우고, "ErrorCode"의 Enum을 만들었습니다.

@Getter
@AllArgsConstructor
public enum ErrorCode {

    INVALID_BATTLE_TIME("최소 10분부터 최대 60분까지 설정 가능합니다."),
    INVALID_USER("유저 설정이 유효하지 않습니다."),
    INVALID_BATTLE_STARTTIME("시작 시간은 최소 60분 후부터 가능합니다."),
    INVALID_OPINION_LENGTH("선택지는 최대 16자까지 작성 가능합니다."),
    DUPLICATED_BATTLE("이미 해당시간에 예정된 배틀이 존재합니다."),
    ENDED_BATTLE("응답 기간이 종료된 배틀입니다.");

    private final String message;
}

Wrong time setting보다 저렇게 친절하게 message를 적어준다면 프론트분들도 처리하기 더더욱 쉽겠죠?ㅎㅎ

public class CustomException extends RuntimeException {

    private final ErrorCode errorCode;

    public CustomException(ErrorCode errorCode) {
       super(errorCode.name());
       this.errorCode = errorCode;
    }

    public ErrorCode getErrorCode() {
       return errorCode;
    }
}

그리고, 저 errorcode를 throw할 수 있는 custom exception을 정의해줍니다.

여기서 잠깐! RuntimeException을 extends하는 이유!
왜 하필 많은 오류 중 Runtime exception일까! 저는 굉장히 궁금했습니다. 사실 이름만 보면 그냥 Exception이 더 일반적으로 보이는데 쓰면 계속 throw를 하래잖아요! 그래서 패트병 대신 텀블러로 커피를 1회 마시고 GPT선생님께 여쭈어봤죠.

RuntimeException과 IllegalArgumentException과 같이 평소에 우리가 사용해도 try-catch 등을 쓰지 않아도 되는 Exception들은 Unchecked Exception이라고 합니다! 그에 반해, 일반 Exception은 Checked Exception이라고 try-catch나 throws를 해야된다고 하네요.

그래서 아무튼 Exception이 아닌 것들 중 가장 무난한 RuntimeException을 채택하였습니다.

그 후 원래 제가 만들어놨던 GlobalExceptionHandler 안에 제 작고 소중한 CustomException도 추가해줬어요...><

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
	public ResponseEntity<ApiResponseDto> handleRuntimeException(RuntimeException error) {
		ApiResponseDto res = new ApiResponseDto("fail", error.getMessage(), null);
		return new ResponseEntity<>(res, HttpStatus.BAD_REQUEST);
	}
    
    //생략

    @ExceptionHandler(CustomException.class)
    public ResponseEntity<ApiResponseDto<String>> handleCustomException(CustomException error) {
        ApiResponseDto<String> response = new ApiResponseDto<>("fail", error.getErrorCode().getMessage(), null);
        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
    }
}

첫번째 메서드가 제가 직접 사용하던 RuntimeException 이고요, 밑이 제가 이제 사용하는 CustomException입니다!!

사실 기능상의 차이는 없어요~! RuntimeException도 message를 반환하고, 제 custom handler도 완전 같은 리턴타입이기에..

하지만, 귀엽잖아요.

다꾸, 폰꾸에 이어 에꾸(에러 꾸미기)까지... 즐겁지않나요?><

그리고 이제 Error을 Throw해주는데 사용될 Validator을 만들어줍니다~

@Component
@AllArgsConstructor
public class BattleValidator {

    static Date now = new Date();
    static Calendar calendar = Calendar.getInstance();
    private final BattleRepository battleRepository;

    public void validateOppositeUser(BattleInviteRequest battleInviteRequest, User user) {
       if (battleInviteRequest.getOppositeUserId() == user.getId()) {
          throw new CustomException(ErrorCode.INVALID_USER);
       }
    }

    public void validateTime(int minutes) {
       if (minutes < 10) {
          throw new CustomException(ErrorCode.INVALID_BATTLE_TIME);
       }
    }

아까랑 똑같은 코드에 똑같은 결과를 반환하는데, 이렇게 설정하는것이 훨씬 간지작살나지 않나요?

이제 서비스단에 이 Validator 내 메서드를 적용하면...!!

@Transactional
@Override
public void registBattle(BattleInviteRequest battleInviteRequest, User user) {

	//생략...

    battleValidator.validateOppositeUser(battleInviteRequest, user);
    battleValidator.validateTime(battleInviteRequest.getTime());
    battleValidator.validateStartTime(battleInviteRequest.getStartDate());
    battleValidator.checkOtherBattles(user, battleInviteRequest.getStartDate(), endDate);
}

TADA!!!!!

나만의 귀여운 코꾸(코드꾸미기...), 완성!!!

아까 말도안되는 if문과 비교해보면,, 훨씬 귀엽고 깜찍해졌죠?

이렇게 작성한 코드는 후에 다른사람이 보았을 때도 이해하기 쉽고, 유지보수도 용이해집니다~

사실 저는 1년전 이맘때쯤, 굉장한 홍머병에 걸렸었는데요,

그때는 플젝때도 남들이 내 코드를 이해하기 어렵고, 건드리지 못하는 것이 뭔가 고수같고 개짱짱맨 코드인 줄 알았답니다...

하하 코드는 무조건 간결!!해야하고 모듈화가 잘 되어있어야합니다~

이거는 알림 기능에서도 적용할 수 있는데요!

어떠한 알림을 보낼 지 프론트님님님들과 상의 후

public enum NotificationType {
    BATTLE_REQUEST(0, "%s님이 배틀을 신청했어요! 지금 바로 확인해보세요."),
    LIVE_NOTICE(1, "[%s] 라이브 시작 5분 전입니다!"),
    BATTLE_ACCEPT(2, "[%s] 배틀이 승낙되어 대기중입니다."),
    BATTLE_DECLINE(3, "[%s] 배틀이 거절되었습니다."),
    BATTLE_UNSATISFIED(4, "[%s] 배틀이 인원수를 충족하지 못해 모닥불로 이동하였습니다."),
    BATTLE_SATISFIED(5, "[%s] 배틀이 인원수를 충족하여 불구경 대기중입니다.");
    //todo 인원 수 미달 -> 모닥불 (참여자, 개최자)
    //todo 인원 수 충족 -> 라이브 개최 (참여자, 개최자)

    private final int code;
    private final String messageTemplate;

    NotificationType(int code, String messageTemplate) {
       this.code = code;
       this.messageTemplate = messageTemplate;
    }

    public int getCode() {
       return code;
    }

    public String getMessageTemplate() {
       return messageTemplate;
    }
}

이렇게 enum으로 정리해놓으며, 추가/수정하면 편하답니다~

그럼 여기서 퀴즈! 알림 메서드들의 문구들을 어떻게하면 더 그럴싸하게 작성할 수 있을까요?(제발도와주세요 저거 넘 구린거같아)

그럼 담에 또봐요 안뇽~~~