[1215] 회문1

✔ 회문1

[SWEA 1215]

문제 분석하기

가로와 세로에서 회문의 길이만큼 이동하면서 대칭될 경우 회문이므로 갯수를 증가

손으로 풀어보기

1. 8 x 8 크기의 배열에 글자를 저장
2. 가로와 세로를 회문의 길이만큼 이동하면서 대칭될 경우 회문 갯수 증가
3. 갯수 반환

슈도코드 작성하기

T(테스트 케이스 수) = 10
for(T만큼) {
    n(찾아야 하는 회문의 길이)
    arr(글자 저장 2차원 배열 (8 x 8 만큼))
    for(i -> arr.length만큼) {
        for (j -> arr.length만큼) {
            arr[i][j] = 글자 저장
        }
    }
    count(횟수)
    for (i -> arr.length만큼) {
        for (j -> arr.length - n + 1만큼) {
            sb(n 길이만큼의 문자)
            for (k -> n만큼) {
                sb.append(arr[i][j + k])
            }
            if (isPalindrome(sb)) {
                count 증가
            }
        }
    }
    for (i -> arr.length - n + 1만큼) {
        for (j -> arr.length만큼) {
            sb(n 길이만큼의 문자)
            for (k -> n만큼) {
                sb.append(arr[i + k][j])
            }
            if (isPalindrome(sb)) {
                count 증가
            }
    }
    #T와 count 반환
}

팰린드롬 함수 구현하기 {
    str(원본 문자열)
    rstr(원본 문자열을 뒤집은 문자열)
    if(동일하다면) {
        return true;
    return false;
}

코드 구현하기

/**
 * 1215) 회문1
 */
public class D002_1215 {
    static char[][] arr;

    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        // T(테스트 케이스 수) = 10
        int T = 10;
        // T만큼
        for (int test_case = 1; test_case <= T; test_case++) {
            // n(찾아야 하는 회문의 길이)
            int n = sc.nextInt();
            // arr(글자 저장 2차원 배열 (8 x 8 만큼))
            arr = new char[8][8];
            // 글자 저장
            for (int i = 0; i < arr.length; i++) {
                String str = sc.next();
                for (int j = 0; j < arr[i].length; j++) {
                    arr[i][j] = str.charAt(j);
                }
            }
            // count(횟수)
            int count = 0;
            // 가로
            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < arr.length - n + 1; j++) {
                    // sb(n 길이만큼의 문자)
                    StringBuffer sb = new StringBuffer();
                    for (int k = 0; k < n; k++) {
                        sb.append(arr[i][j + k]);
                    }
                    // 대칭인지 확인
                    if (isPalindrome(sb)) {
                        // 대칭이라면 count 증가
                        count++;
                    }
                }
            }
            // 세로
            for (int i = 0; i < arr.length - n + 1; i++) {
                for (int j = 0; j < arr.length; j++) {
                    // sb(n 길이만큼의 문자)
                    StringBuffer sb = new StringBuffer();
                    for (int k = 0; k < n; k++) {
                        sb.append(arr[i + k][j]);
                    }
                    // 대칭인지 확인
                    if (isPalindrome(sb)) {
                        // 대칭이라면 count 증가
                        count++;
                    }
                }
            }
            // #T와 count 반환
            System.out.println("#" + test_case + " " + count);
        }
    }

    // 팰린드롬 함수 구현하기
    private static boolean isPalindrome(StringBuffer sb) {
        // str(원본 문자열)
        String str = sb.toString();
        // rstr(원본 문자열을 뒤집은 문자열)
        String rstr = sb.reverse().toString();
        // 동일하다면
        if (str.equals(rstr)) {
            return true;
        }
        return false;
    }
}