백준 폭탄 해체

문제

내가 생각했을때 문제에서 원하는부분

입력으로 폭탄의 코드가 주어진다. 코드는 2자리 이상, 8자리 이하이고, 각 자리는 5행 3열의 문자로 주어진다.
문자는 공백과 별표('*') 중 하나이다.
또, 각 숫자를 구분하기 위해 숫자 사이에는 빈 칸이 하나씩 있다.
모든 숫자는 5×3 크기이지만, 올바르지 않은 숫자가 주어질 수도 있다.
올바르지 않은 숫자가 주어진 경우에는 전선을 자르면 안 된다.
0부터 9까지 숫자를 5×3으로 나타내는 방법은 아래에 나와있다.
### ### ### ### ### ### ### ### ### ###
***   * *** *** * * *** *** *** *** ***
* *   *   *   * * * *   *     * * * * *
* *   * *** *** *** *** ***   * *** ***
* *   * *     *   *   * * *   * * *   *
***   * *** ***   * *** ***   * *** ***
그림 1. 맨 위의 #는 열을 알아보기 쉽게 하기 위해 주어진 문자이다.
코드는 0으로 시작하는 숫자일 수도 있다. 예를 들어, 00000076는 76이다.

첫째 줄에 입력으로 주어진 코드인 경우에 전선을 잘라도 되면 "BEER!!"를, 자르면 폭발하는 경우에는 "BOOM!!"을 출력한다.

내가 이 문제를 보고 생각해본 부분

입력을 빠르고 편리하게 처리하기 위해 BufferedReader를 사용한다.
digits 배열에 0부터 9까지 숫자를 5행 3열 문자 패턴으로 미리 정의한다.
각 숫자 패턴을 연속된 문자열로 합쳐 맵에 저장해서 패턴을 찾기 쉽게 했다.
입력으로 5줄을 받습니다. 각 줄의 길이를 이용하여 총 숫자 개수를 구한다.
각 숫자를 3글자씩 슬라이스해서 5줄을 이어 붙여 하나의 숫자 패턴을 만든다.
이 패턴이 사전에 정의된 patternMap에 없으면 무조건 "BOOM!!".
모든 숫자가 올바르면 6으로 나눠지는지 확인하여 맞으면 "BEER!!" 아니면 "BOOM!!" 출력한다.
숫자는 최대 8자리라서 long으로 안전하게 처리할 수 있다.
마지막에 BufferedReader를 닫아 자원을 정리한다.

코드로 구현

package baekjoon.baekjoon_32;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

// 백준 9242번 문제
public class Main1296 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 0~9 숫자의 5행 3열 패턴 정의
        String[][] digits = {
                {
                        "***",
                        "* *",
                        "* *",
                        "* *",
                        "***"
                }, //0
                {
                        "  *",
                        "  *",
                        "  *",
                        "  *",
                        "  *"
                }, //1
                {
                        "***",
                        "  *",
                        "***",
                        "*  ",
                        "***"
                }, //2
                {
                        "***",
                        "  *",
                        "***",
                        "  *",
                        "***"
                }, //3
                {
                        "* *",
                        "* *",
                        "***",
                        "  *",
                        "  *"
                }, //4
                {
                        "***",
                        "*  ",
                        "***",
                        "  *",
                        "***"
                }, //5
                {
                        "***",
                        "*  ",
                        "***",
                        "* *",
                        "***"
                }, //6
                {
                        "***",
                        "  *",
                        "  *",
                        "  *",
                        "  *"
                }, //7
                {
                        "***",
                        "* *",
                        "***",
                        "* *",
                        "***"
                }, //8
                {
                        "***",
                        "* *",
                        "***",
                        "  *",
                        "***"
                }  //9
        };

        // 숫자 모양 패턴을 문자열로 합쳐서 키로 저장
        Map<String, Integer> patternMap = new HashMap<>();
        for (int i = 0; i <= 9; i++) {
            StringBuilder sb = new StringBuilder();
            for (int r = 0; r < 5; r++) {
                sb.append(digits[i][r]);
            }
            patternMap.put(sb.toString(), i);
        }

        // 입력받기 (5줄)
        String[] lines = new String[5];
        for (int i = 0; i < 5; i++) {
            lines[i] = br.readLine();
        }

        // 한 줄에 숫자는 (문자 길이 + 1) / 4개이다.
        // 숫자 사이 공백 1칸 포함해서 숫자 모양의 가로 폭은 3 + 1 = 4
        int numCount = (lines[0].length() + 1) / 4;

        StringBuilder codeStr = new StringBuilder();

        for (int idx = 0; idx < numCount; idx++) {
            StringBuilder digitStr = new StringBuilder();
            // 5줄, 각 줄 idx*4부터 3글자씩 가져옴
            for (int r = 0; r < 5; r++) {
                digitStr.append(lines[r], idx * 4, idx * 4 + 3);
            }
            String digitPattern = digitStr.toString();

            if (!patternMap.containsKey(digitPattern)) {
                // 올바른 숫자 모양이 아님
                System.out.println("BOOM!!");
                br.close();
                return;
            }
            codeStr.append(patternMap.get(digitPattern));
        }

        // 숫자 스트링을 6으로 나눌 수 있는지 체크
        // 숫자 범위가 커도 long 사용 가능 (8자리까지)
        long codeNum = Long.parseLong(codeStr.toString());

        if (codeNum % 6 == 0) {
            System.out.println("BEER!!");
        } else {
            System.out.println("BOOM!!");
        }

        br.close();
    }
}

마무리

코드와 설명이 부족할수 있습니다. 코드를 보시고 문제가 있거나 코드 개선이 필요한 부분이 있다면 댓글로 말해주시면 감사한 마음으로 참고해 코드를 수정 하겠습니다.