극동대학교\AI컴퓨터공학과\JAVA/프로그래머스 코딩 기초 트레이닝

[프로그래머스, LV.0] 정수를 나선형으로 배치하기

sundori 2023. 5. 14. 03:06

목차

    #1 정수를 나선형으로 배치하기.


    #2 코드 및 알고리즘

    class Solution {
        public int[][] solution(int n) {
            int x = 0; // x축 방향
            int y = 0; // y축 방향
            int temp = 0; // 각 축의 방향 임시 저장 변수
            int value = 1; // 1~n 즉, 채워야할 정수 값.
            int[][] twoArr = new int[n][n];
            while(value <= n * n){ // 배열에 전부 채워지면 종료.
                for(int right = x; right < n - x; right++){ // x 축 증가 for문.
                    twoArr[y][right] = value++;
                    temp = right;// x 축으로 증가.
                    if(value  >= n * n)
                        break;
                } y++; x = temp;
                for(int down = y; down <= n - y; down++){ // y 축으로 증가 for문.
                    twoArr[down][x] = value++;
                    temp = down;
                    if(value  >= n * n)
                        break;
                } x--; y = temp;
                for(int left = x; left >= n - 1 - y; left--){ // x 축 감소 for문.
                    twoArr[y][left] = value++;
                    temp = left;
                    if(value  >= n * n)
                        break;
                }y--; x = temp;
                for(int up = y; up > x; up--){ // y 축 감소 for문.
                    twoArr[up][x] = value++;
                    temp = up;
                    if(value  >= n * n)
                        break;
                }x++; y = temp;
            }
            return twoArr;
        }
    }

    이번 문제는 나선형으로 돌면서 숫자를 차례대로 1씩 증가하면서 빈 공간을 채워나가는 것이다.

     

    풀이:

    1. 배열 n*n 크기만큼 선언.
    2. while문으로 모두 채워질 때까지 반복.
    3. temp 변수를 활용하여 각 축에 변화를 저장.

    #3 결과 및  테스트 실행 결과

    // 코드 실행 결과 4 * 4 크기
    [1,   2,  3, 4]
    [12, 13, 14, 5]
    [11, 16, 15, 6]
    [10,  9,  8, 7]
    정확성  테스트
    테스트 1 〉	통과 (0.02ms, 76.8MB)
    테스트 2 〉	통과 (0.02ms, 75.6MB)
    테스트 3 〉	통과 (0.04ms, 77.8MB)
    테스트 4 〉	통과 (0.03ms, 79MB)
    테스트 5 〉	통과 (0.04ms, 76.4MB)
    테스트 6 〉	통과 (0.04ms, 74.6MB)
    테스트 7 〉	통과 (0.03ms, 77.4MB)
    테스트 8 〉	통과 (0.04ms, 75.7MB)
    테스트 9 〉	통과 (0.04ms, 75.7MB)
    테스트 10 〉	통과 (0.04ms, 75MB)
    테스트 11 〉	통과 (0.05ms, 76.1MB)
    테스트 12 〉	통과 (0.04ms, 76.3MB)
    테스트 13 〉	통과 (0.01ms, 73.6MB)
    테스트 14 〉	통과 (0.03ms, 76.2MB)
    테스트 15 〉	통과 (0.04ms, 78.5MB)
    테스트 16 〉	통과 (0.02ms, 74.2MB)
    테스트 17 〉	통과 (0.08ms, 83.7MB)
    테스트 18 〉	통과 (0.03ms, 71.6MB)
    테스트 19 〉	통과 (0.03ms, 74.8MB)
    테스트 20 〉	통과 (0.06ms, 75.7MB)
    테스트 21 〉	통과 (0.03ms, 72MB)
    테스트 22 〉	통과 (0.03ms, 72.2MB)
    테스트 23 〉	통과 (0.03ms, 76.5MB)
    테스트 24 〉	통과 (0.04ms, 73.4MB)
    테스트 25 〉	통과 (0.06ms, 74.2MB)
    테스트 26 〉	통과 (0.03ms, 75.8MB)
    테스트 27 〉	통과 (0.03ms, 74MB)
    테스트 28 〉	통과 (0.05ms, 74.1MB)
    채점 결과
    정확성: 100.0
    합계: 100.0 / 100.0

    #4 알고리즘 순서.

     

    public static void main(String[] args) {
            int n = 4;
            int x = 0; // x축 방향
            int y = 0; // y축 방향
            int temp = 0; // 각 축의 방향 임시 저장 변수
            int value = 1; // 1~n 즉, 채워야할 정수 값.
            int[][] twoArr = new int[n][n];
            
            while (value <= n * n) { // 배열에 전부 채워지면 종료.
                for (int right = x; right < n - x; right++) { // x 축 증가 for문.
                    twoArr[y][right] = value++;
                    temp = right;// x 축으로 증가.
                    if (value >= n * n)
                        break;
                }
                y++;
                x = temp;
            }
    }

    x축 증가 결과.

    다음 for 문의 시작 위치 (x축 :3 y축 :1)
    	[1, 2, 3, 4]
    	[0, 0, 0, 0]
    	[0, 0, 0, 0]
    	[0, 0, 0, 0]
            while (value <= n * n) { // 배열에 전부 채워지면 종료.
                for (int right = x; right < n - x; right++) { // x 축 증가 for문.
                    twoArr[y][right] = value++;
                    temp = right;// x 축으로 증가.
                    if (value >= n * n)
                        break;
                }
                y++;
                x = temp;
                for (int down = y; down <= n - y; down++) { // y 축으로 증가 for문.
                    twoArr[down][x] = value++;
                    temp = down;
                    if (value >= n * n)
                        break;
                }
                x--;
                y = temp;
            }

    y축 증가 결과.

    다음 for 문의 시작 위치 (x축 :2 y축 :3)
    	[1, 2, 3, 4]
    	[0, 0, 0, 5]
    	[0, 0, 0, 6]
    	[0, 0, 0, 7]
            while (value <= n * n) { // 배열에 전부 채워지면 종료.
                for (int right = x; right < n - x; right++) { // x 축 증가 for문.
                    twoArr[y][right] = value++;
                    temp = right;// x 축으로 증가.
                    if (value >= n * n)
                        break;
                }
                y++;
                x = temp;
                for (int down = y; down <= n - y; down++) { // y 축으로 증가 for문.
                    twoArr[down][x] = value++;
                    temp = down;
                    if (value >= n * n)
                        break;
                }
                x--;
                y = temp;
                for (int left = x; left >= n - 1 - y; left--) { // x 축 감소 for문.
                    twoArr[y][left] = value++;
                    temp = left;
                    if (value >= n * n)
                        break;
                }
                y--;
                x = temp;
           }

    x축 감소 결과.

    다음 for 문의 시작 위치 (x축 :0 y축 :2)
    	[1,  2, 3, 4]
    	[0,  0, 0, 5]
    	[0,  0, 0, 6]
    	[10, 9, 8, 7]
            while (value <= n * n) { // 배열에 전부 채워지면 종료.
                for (int right = x; right < n - x; right++) { // x 축 증가 for문.
                    twoArr[y][right] = value++;
                    temp = right;// x 축으로 증가.
                    if (value >= n * n)
                        break;
                }
                y++;
                x = temp;
                for (int down = y; down <= n - y; down++) { // y 축으로 증가 for문.
                    twoArr[down][x] = value++;
                    temp = down;
                    if (value >= n * n)
                        break;
                }
                x--;
                y = temp;
                for (int left = x; left >= n - 1 - y; left--) { // x 축 감소 for문.
                    twoArr[y][left] = value++;
                    temp = left;
                    if (value >= n * n)
                        break;
                }
                y--;
                x = temp;
                for (int up = y; up > x; up--) { // y 축 감소 for문.
                    twoArr[up][x] = value++;
                    temp = up;
                    if (value >= n * n)
                        break;
                }
                x++;
                y = temp;
            }

    y축 감소 결과.

    다음 for 문의 시작 위치 (x축 :1 y축 :1)
    	[1,  2, 3, 4]
    	[12, 0, 0, 5]
    	[11, 0, 0, 6]
    	[10, 9, 8, 7]

    2번째 while문.

                for (int right = x; right < n - x; right++) { // x 축 증가 for문.
                    twoArr[y][right] = value++;
                    temp = right;// x 축으로 증가.
                    if (value >= n * n)
                        break;
                }
                y++;
                x = temp;
    다음 for 문의 시작 위치 (x축 :2 y축 :2)
    	[1,  2,  3,  4]
    	[12, 13, 14, 5]
    	[11, 0,  0,  6]
    	[10, 9,  8,  7]

     

                for (int right = x; right < n - x; right++) { // x 축 증가 for문.
                    twoArr[y][right] = value++;
                    temp = right;// x 축으로 증가.
                    if (value >= n * n)
                        break;
                }
                y++;
                x = temp;
                for (int down = y; down <= n - y; down++) { // y 축으로 증가 for문.
                    twoArr[down][x] = value++;
                    temp = down;
                    if (value >= n * n)
                        break;
                }
    다음 for 문의 시작 위치 (x축 :2 y축 :2)
    	[1,  2,  3,  4]
    	[12, 13, 14, 5]
    	[11, 0,  15, 6]
    	[10, 9,  8,  7]
                for (int right = x; right < n - x; right++) { // x 축 증가 for문.
                    twoArr[y][right] = value++;
                    temp = right;// x 축으로 증가.
                    if (value >= n * n)
                        break;
                }
                y++;
                x = temp;
                for (int down = y; down <= n - y; down++) { // y 축으로 증가 for문.
                    twoArr[down][x] = value++;
                    temp = down;
                    if (value >= n * n)
                        break;
                }
                x--;
                y = temp;
                for (int left = x; left >= n - 1 - y; left--) { // x 축 감소 for문.
                    twoArr[y][left] = value++;
                    temp = left;
                    if (value >= n * n)
                        break;
                }
                y--;
                x = temp;
    다음 for 문의 시작 위치 (x축 :1 y축 :1)
    	[1,   2,  3, 4]
    	[12, 13, 14, 5]
    	[11, 16, 15, 6]
    	[10,  9,  8, 7]

    긴 글이 되었지만 이러한 방식의 알고리즘으로 만들게 되었다. 나선형의 방향 그대로 순서를 주었다.