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

목차

#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]

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