Spiral Array

문제는 다음과 같다:

6 6

  0   1   2   3   4   5
 19  20  21  22  23   6
 18  31  32  33  24   7
 17  30  35  34  25   8
 16  29  28  27  26   9
 15  14  13  12  11  10

위처럼 6 6이라는 입력을 주면 6 X 6 매트릭스에 나선형 회전을 한 값을 출력해야 한다.

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

146개의 풀이가 있습니다. 1 / 15 Page

n=input()
n=int(n)

a = [[0 for col in range(n)] for row in range(n)]
row=0#행
col=0#열
num=0#행렬에 들어갈 숫자
if n%2==0:#n=짝수일때
    cur=n-1
    tmp=n
    while cur>0:
        while col<cur:# right move
            a[row][col]=num
            num+=1
            col+=1
        while row<cur:# down move
            a[row][col]=num
            num+=1
            row+=1
        while col>=tmp-cur:# left move
            a[row][col]=num
            num+=1
            col-=1
        while row>=tmp-cur:#up move
            a[row][col]=num
            num+=1
            row-=1
        row+=1
        col+=1
        cur-=1#4
else:
    cur=n-1
    tmp=n
    while cur>1:
        while col<cur:# right move
            a[row][col]=num
            num+=1
            col+=1
        while row<cur:# down move
            a[row][col]=num
            num+=1
            row+=1
        while col>=tmp-cur:# left move
            a[row][col]=num
            num+=1
            col-=1
        while row>=tmp-cur:#up move
            a[row][col]=num
            num+=1
            row-=1
        row+=1
        col+=1
        cur-=1

    row=(int)(tmp/2)
    col=row
    a[row][col]=num

for i in range(n):
    for j in range(n):
        print(a[i][j],end=" ")
    print("\n")

``````{.python}
n=input()
n=int(n)

a = [[0 for col in range(n)] for row in range(n)]
row=0#행
col=0#열
num=0#행렬에 들어갈 숫자
if n%2==0:#n=짝수일때
    cur=n-1
    tmp=n
    while cur>0:
        while col<cur:# right move
            a[row][col]=num
            num+=1
            col+=1
        while row<cur:# down move
            a[row][col]=num
            num+=1
            row+=1
        while col>=tmp-cur:# left move
            a[row][col]=num
            num+=1
            col-=1
        while row>=tmp-cur:#up move
            a[row][col]=num
            num+=1
            row-=1
        row+=1
        col+=1
        cur-=1#4
else:
    cur=n-1
    tmp=n
    while cur>1:
        while col<cur:# right move
            a[row][col]=num
            num+=1
            col+=1
        while row<cur:# down move
            a[row][col]=num
            num+=1
            row+=1
        while col>=tmp-cur:# left move
            a[row][col]=num
            num+=1
            col-=1
        while row>=tmp-cur:#up move
            a[row][col]=num
            num+=1
            row-=1
        row+=1
        col+=1
        cur-=1

    row=(int)(tmp/2)
    col=row
    a[row][col]=num

for i in range(n):
    for j in range(n):
        print(a[i][j],end=" ")
    print("\n")

print(row,col)
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

def fspiral(N, M):

scale = N*M
count = 0 # 짝수면 반복문 전부 홀수면 절반 실행
x = 0
R = 0 # 싸이클이 끝나고 의 현재의 값 R

# k의 범위 구하기
while(scale > 0):
    if N-2*x-1 == 0 or M-2*x-1 == 0 :
        scale -= (M-2*x-1 + N-2*x-1 +1)
        count += 1
    else:
        scale -= (M-2*x-1 + N-2*x-1) 
        count += 1
    if scale != 0 :
        scale -= (M-2*x-1 + N-2*x-1)
        count += 1
    x += 1


# 2차원 배열 만들기
matrix = [[0 for row in range(M)] for col in range(N)]


#나선형으로 진행하는 좌표 
for k in range(x):
    #처음만 y좌표를 0으로 놓음
    #1
    if M-2*k-1 != 0 :
        for i1 in range(k, M-(k+2)+1):
            if k ==0:
                matrix[0][i1] = i1-k
                R = i1-k

            else:
                matrix[k][i1] = u + R 
                R = u + R

    else :
        matrix[k][k] = 1 + R 
        R = 1 + R


    #2
    if N-2*k-1  != 0:
        for i2 in range(k, N-(k+2)+1):
            u = 0
            u += 1
            matrix[i2][M-k-1] = u + R 
            R = u + R

    elif M-2*k-1 == 0 and N-2*k-1 == 0 :
        pass
    else :
        matrix[k][M-k-1] = 1+R 
        R = 1 + R
        print("2 %s" %R)

    count -= 1
    print("count= %s" %count)
    if count != 0:
        #3
        for i3 in list(reversed(range(k+1, M-(k+1)+1))):
            u = 0
            u += 1
            matrix[N-k-1][i3] =  u+R
            R = u+ R

        #4
        for i4 in list(reversed(range(k+1, N-(k+1)+1))):
            u = 0
            u += 1
            matrix[i4][k] = u + R 
            R = u+ R


        count -= 1

    else:
        break



# matrix 프린트
for X in range(N):
    for Y in range(M):
        chr1 = matrix[X][Y]
        print("%3d" %chr1, end = "")
    print("\n")
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

import java.util.Scanner;

public class Algorithm {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    int right =0;
    int down =1;
    int left =2;
    int up =3;
    int direction = right;  
    Scanner sc = new Scanner(System.in);
    int row = sc.nextInt();
    int col = sc.nextInt();
    int end = row*col;
    int[][] result = new int[row][col];
    boolean[][] data  = new boolean[row][col];

    int hori = -1;
    int verti = 0;

    for(int i=0; i<end; i++){
        if(direction == right){
            hori++;
            if(hori>=col || data[verti][hori]){
                hori--; verti++;
                result[verti][hori] = i;
                data[verti][hori] = true;
                direction = down;
            }else{
                result[verti][hori] = i;
                data[verti][hori] = true;
            }
        }else if(direction == down){
            verti++;
            if(verti>=row || data[verti][hori]){
                verti--; hori--;
                result[verti][hori] = i;
                data[verti][hori] = true;
                direction = left;
            }else{
                result[verti][hori] = i;
                data[verti][hori] = true;
            }
        }else if(direction == left){
            hori--;
            if(hori<0 || data[verti][hori]){
                hori++; verti--;
                result[verti][hori] = i;
                data[verti][hori] = true;
                direction = up;
            }else{
                result[verti][hori] = i;
                data[verti][hori] =true;
            }
        }           
        else if(direction == up){
            verti--;
            if(data[verti][hori]){
                verti++; hori++;
                result[verti][hori] = i;
                data[verti][hori] = true;
                direction = right;
            }else{
                result[verti][hori] = i;
                data[verti][hori] = true;
            }
        }

    }

    for(int i=0; i<row;i++){
        for(int j=0; j<col; j++){
            if(result[i][j] <10){
                System.out.print("   "+result[i][j]);
            }else{
            System.out.print("  "+result[i][j]);}
        }
        System.out.println("");
    }
}

}

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

int n = 6, m = 6; String[][] str = new String[n][n];

    int k = 0;
    int ii = 0;

    while(k < m*m) {

        for(int j=ii; j<n; j++) {
            str[ii][j] = String.valueOf(k++);
        }

        for(int i=(ii+1); i<n; i++) { 
            str[(i)][n-1] = String.valueOf(k++);
        }

        for(int j = (n-2); j >= ii; j--) { 
            str[n-1][j] = String.valueOf(k++);
        }

        for(int i = (n-2); i > ii; i-- ) {  
            str[i][ii] = String.valueOf(k++);
        }

        n--;
        ii++;
    }

    for(int i = 0; i<m;i++)
        for(int j=0; j<m; j++) {
            System.out.print(str[i][j]+", ");
            if (j > 0 && j % (m-1) == 0) 
                System.out.println(" ");
        }
}
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
import java.util.Scanner;

public class practiceMain {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int row = s.nextInt();
        int col = s.nextInt();
        //시작하면 행렬 크기를 입력받는다

        int[][] matrix = new int[row][col];
        //숫자를 저장할 행렬 선언
        int count = row*col;
        //행렬에 저장될 인자가 총 몇개인지

        for(int i=0; i<row; i++){
            for(int j=0; j<col; j++){
                matrix[i][j] = -1;
            }
        }//매트릭스 초기화

        int matrixDirection = 0;
        //방향을 나타낸다. 변환 주기는 →(0) - ↓(1) - ←(2) - ↑(3) - →(0)
        int currentRow=0;
        int currentCol=0;
        //행렬내 좌표값 체킹 위해...

        for(int i=0; i<count; i++){
            switch(matrixDirection){
                case 0:
                    if((currentCol+1) >= col){
                        matrixDirection++;
                        matrix[currentRow][currentCol]=i;
                        System.out.println("direction change:"+i+", direction:"+matrixDirection);
                        break;
                    }else if(matrix[currentRow][currentCol+1]!=-1){
                        //오른쪽으로 갈 다음 칸이 이미 차있는 칸이거나... 혹은 끝일경우
                        matrixDirection++;
                        matrix[currentRow][currentCol]=i;
                        System.out.println("direction change:"+i);
                        break;
                    }
                    matrix[currentRow][currentCol]=i;
                    System.out.println("row:"+currentRow+", col:"+currentCol+", i:"+i);
                    break;

                case 1:
                    if((currentRow+1) >= row){
                        matrixDirection++;
                        matrix[currentRow][currentCol]=i;
                        break;
                    }else if(matrix[currentRow+1][currentCol]!=-1){
                        //아래로 갈 다음 칸이 이미 차있는 칸이거나... 혹은 끝일경우
                        matrixDirection++;
                        matrix[currentRow][currentCol]=i;
                        System.out.println("direction change:"+i);
                        break;
                    }
                    matrix[currentRow][currentCol]=i;
                    System.out.println("row:"+currentRow+", col:"+currentCol+", i:"+i);
                    break;  

                case 2:
                    if(currentCol <= 0){
                        matrixDirection++;
                        matrix[currentRow][currentCol]=i;
                        break;
                    }else if(matrix[currentRow][currentCol-1]!=-1){
                        //왼쪽으로 갈 다음 칸이 이미 차있는 칸이거나... 혹은 끝일경우
                        matrixDirection++;
                        matrix[currentRow][currentCol]=i;
                        System.out.println("direction change:"+i);
                        break;
                    }
                    matrix[currentRow][currentCol]=i;
                    System.out.println("row:"+currentRow+", col:"+currentCol+", i:"+i);
                    break;

                case 3:
                    if(currentRow <= 0){
                        matrixDirection=0;
                        matrix[currentRow][currentCol]=i;
                        break;
                    }else if(matrix[currentRow-1][currentCol]!=-1){
                        //위로 갈 다음 칸이 이미 차있는 칸이거나... 혹은 끝일경우
                        matrixDirection=0;
                        matrix[currentRow][currentCol]=i;
                        System.out.println("direction change:"+i);
                        break;
                    }
                    matrix[currentRow][currentCol]=i;
                    System.out.println("row:"+currentRow+", col:"+currentCol+", i:"+i);
                    break;      
            }           
            //두번째 switch문에서는 방향값 조정
            switch(matrixDirection){
                case 0:
                    currentCol++;
                    break;
                case 1:
                    currentRow++;
                    break;
                case 2:
                    currentCol--;
                    break;
                case 3:
                    currentRow--;
                    break;
            }
            //가로로 갈 경우와
            //세로로 갈 경우를 나눠야 한당
            //어떻게!?         
        }


        for(int i=0; i<row; i++){
            for(int j=0; j<col; j++){
                System.out.print(matrix[i][j]+"\t");
            }
            System.out.println("");
        }
    }

}

자바로 미흡하게나마 짜봤어영

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

X,Y = 10,6

# 초기화
go = 1
x,y = 0,0
min_x, min_y, max_x, max_y = 0 , 0, X-1, Y-1
result = [[-1 for i in range(0,X)] for j in range(0,Y)]

for i in range(0,X*Y):
    result[y][x] = i

    # 방향 지정
    if x == max_x and go == 1 :
        go = 2
    elif y == max_y and go == 2 :
        go = 3
    elif x == min_x and go == 3:
        go = 4

        # 증가 범위 재설정
        min_y += 1
        min_x += 1
        max_x -= 1
        max_y -= 1
    elif y == min_y and go == 4:
        go = 1

    # 배열위치값 증감
    if go == 1:
        x += 1
    elif go == 2:
        y += 1
    elif go == 3:
        x -= 1
    elif go == 4:
        y -= 1

# 출력
for row in result:
    for chk in row:
        print '%3d'%chk,
    print


초기화와 출력은 다른분 소스를 참고하고 스파이럴 배열 입력부분은 각 끝자리의 위치값을 셋팅하고 한바퀴돌때마다 끝자리 위치값이 하나씩 줄어들면 가능하다고 보고 구현

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

어제 풀이를 한번 올렸었는데 맘에 안들어서 한번 더 했네요ㅠㅠㅠㅠㅠ이것도 완전 맘에 들지는 않지만....

import java.util.*;
enum Direction{
    RIGHT, LEFT, UP, DOWN
}


class Spiral_Array_v2 {
    public static void main(String[] args) {
        Scanner robot = new Scanner(System.in);

        System.out.print("입력 : ");
        int x = robot.nextInt();
        System.out.print("입력 : ");
        int y = robot.nextInt();

        Direction dir = Direction.RIGHT;

        int[][] arr = new int[x][y];

        for(int[] o : arr){
            Arrays.fill(o, -1);
        }

        int xp = 0;
        int yp = 0;
        int num = 0;

/********************************************************************/

        while(num < x*y){

            arr[xp][yp] = num++;
            if(num == x*y) break;

            if( (dir == Direction.RIGHT && yp+1 < y && arr[xp][yp+1] == -1)  
                || ( dir == Direction.DOWN && xp+1 < x && arr[xp+1][yp] == -1 )
                || ( dir == Direction.LEFT && yp-1 >= 0 && arr[xp][yp-1] == -1 )
                || ( dir == Direction.UP && xp-1 >= 0 && arr[xp-1][yp] == -1 )){
            }else{
                if( dir == Direction.RIGHT ){
                    dir = Direction.DOWN;
                }else if(dir == Direction.DOWN){
                    dir = Direction.LEFT;
                }else if(dir == Direction.LEFT){
                    dir = Direction.UP;
                }else{
                    dir = Direction.RIGHT;
                }
            }

            switch(dir){
                case RIGHT  : ++yp; break;
                case DOWN   : ++xp; break;
                case LEFT   : --yp; break;
                case UP     : --xp; break;
            }
        }

/********************************************************************/

        for(int i = 0; i < arr.length; i++){
            for(int j = 0 ; j < arr[0].length ; j++){
                String str = arr[i][j] < 10 ? " 0"+arr[i][j] : " "+arr[i][j];
                System.out.print(str);
            }
            System.out.println();
        }
    }
}

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
import java.util.*;
class Spiral_Array {
    public static void main(String[] args) {
        /*
            6 6

            0   1   2   3   4   5
            19  20  21  22  23   6
            18  31  32  33  24   7
            17  30  35  34  25   8
            16  29  28  27  26   9
            15  14  13  12  11  10

            위처럼 6 6이라는 입력을 주면 6 X 6 매트릭스에 나선형 회전을 한 값을 출력해야 한다.

            3 7

            0  1  2  3  4  5  6
            15 16 17 18 19 20 7
            14 13 12 11 10 9  8
        */

        Scanner robot = new Scanner(System.in);
        System.out.print("입력 : ");
        int x = robot.nextInt();
        System.out.print("입력 : ");
        int y = robot.nextInt();

        int[][] arr = new int[x][y];
        /*
            → ↓ ← ↑
        */
        int xp = 0;
        int yp = 0;
        int ps = 1;

        for(int i=1 ; i < x*y ; i++){

            while(i < x*y){
                int ps_temp = ps;

                if(ps == 1 && yp+1 < y && arr[xp][yp+1] == 0 ){
                    arr[xp][yp+1] = i;
                    yp++;

                }else if(ps == 2 && xp+1 < x && arr[xp+1][yp] == 0 ){
                    arr[xp+1][yp] = i;
                    xp++;

                }else if(ps == 3 && yp-1 >= 0 && arr[xp][yp-1] == 0 ){
                    arr[xp][yp-1] = i;              
                    yp--;

                }else if(ps == 4 && xp-1 > 0 && arr[xp-1][yp] == 0 ){
                    arr[xp-1][yp] = i;
                    xp--;

                    if(xp == 0 && yp == 0){ 
                        xp++;
                        ps = 1; 
                    }

                }else{
                    if(ps < 4){
                        ps++;
                    }else{
                        ps = 1;
                    }
                }
                if(ps_temp != ps){
                    i--;
                }
                i++;
            }
        }

        for(int i = 0; i < arr.length; i++){
            for(int j = 0 ; j < arr[0].length ; j++){
                String str = arr[i][j] < 10 ? " 0"+arr[i][j] : " "+arr[i][j];
                System.out.print(str);
            }
            System.out.println();
        }
    }
}

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
# 코딩도장 002. Spiral Array
# Notepad++ (Windows 32bits 7.3.3)
# Python 3.5.2 (AMD64)
#
# N X M 매트릭스의 경우,
# 
# 규칙 1) 
# EAST direction으로 진행하고, 다음에는 SOUTH, WEST 그리고 NORTH로 진행하며
# 다시 EAST로 순환하는 구조를 가진다.
#
# 규칙 2)
# 좌상단의 첫 숫자는 1이며 
# 그 다음 direction까지는 다음의 숫자만큼만 1씩 증가하면서 진행하고 direction을 바꾼다.
#   N-1, M-1, N-1, M-2, N-2, ...
#   즉 처음에는 N-1번 진행을 하지만 그 다음부터는 M과 N의 숫자를 하나씩 줄여가면서 진행한다.
#   그래서 N 또는 M의 값이 0까지 진행을 하면 멈춘다.
#   6 * 5의 경우,
#   6-1, 5-1, 6-1, 5-2, 6-2, 5-3, 6-3, 5-4, 6-4, 5-5 <-- 여기서 멈추게 된다.
#   즉 5, 4, 5, 3, 4, 2, 3, 1, 2, 0 <--- 여기서 멈추게 된다.
#   이는 코드에서 spin_order로 표현되어 있다.
#
# 규칙 2를 이용하여 각각의 direction으로 몇 칸씩 가야 하는지 확인한 후 이동한다.

N = 5
M = 5

###### 규칙 2 시작
spin_order = list()

n = N
m = M

spin_order.append(N-1)
while(True):
    m = m - 1
    if m == 0:
        break
    else:
        spin_order.append(m)

    n = n - 1
    if n == 0:
        break
    else:
        spin_order.append(n)

###### 규칙 2 종료

# 2차원 배열을 0으로 초기화
# ddegul님 https://goo.gl/bNKCs1 참조
result = [[0 for col in range(N)] for row in range(M)]

pos_x = 0
pos_y = 0
num = 1
result[pos_x][pos_y] = num
direction = "EAST"

for i in spin_order:
    for j in range(i):
        num = num + 1
        if direction == "EAST":
            pos_x = pos_x + 1
            result[pos_x][pos_y] = num

        if direction == "SOUTH":
            pos_y = pos_y + 1
            result[pos_x][pos_y] = num

        if direction == "WEST":
            pos_x = pos_x - 1
            result[pos_x][pos_y] = num

        if direction == "NORTH":
            pos_y = pos_y - 1
            result[pos_x][pos_y] = num

    if direction == "EAST":
        direction = "SOUTH"
    elif direction == "SOUTH":
        direction = "WEST"
    elif direction == "WEST":
        direction = "NORTH"
    elif direction == "NORTH":
        direction = "EAST"

for i in range(len(result)):
    for j in range(len(result[0])):
        print("%4d" %(result[j][i]), end = " ")
    print("")

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
#include    <iostream>
#include    <stdio.h>
#include    <string.h>
#include    <stdlib.h>

using namespace std;

namespace STATE
{
    typedef enum
    {
        LEFT ,
        RIGHT ,
        UP ,
        DOWN
    }Enum;
}

class Spiral
{
    private:
        int    mX;
        int    mY;
        int    mValue;

        STATE::Enum    mState;
        int**    mpBuffer;
        int    mVertical;
        int    mHorizon;

    public:
        Spiral( int rVertical , int rHorizon )
        {
            mState = STATE::RIGHT;
            mVertical = rVertical;
            mHorizon = rHorizon;
            mpBuffer = ( int** )calloc( mVertical , sizeof( int* ) );
            for( int i = 0 ; i < mVertical ; ++i )
            {
                mpBuffer[ i ] = ( int* )malloc( mHorizon * sizeof( int ) );
                for( int j = 0 ; j < mHorizon ; ++j )
                {
                    mpBuffer[ i ][ j ] = -1;
                }
            }
            mX    = 0;
            mY    = 0;
            mValue    = 0;
            mpBuffer[ 0 ][ 0 ] = 0;
        }

        virtual ~Spiral()
        {
            for( int i = 0 ; i < mVertical ; ++i )
            {
                free( mpBuffer[ i ] );
            }
            free( mpBuffer );
        }

        int    ShiftLeft()
        {
            if( ( mY - 1 ) >= 0 && mpBuffer[ mX ][ mY - 1 ] == -1 )
            {
                mpBuffer[ mX ][ --mY ] = ++mValue;
                return    0;
            }
            return    -1;
        }
        int    ShiftRight()
        {
            if( ( mY + 1 ) < mHorizon && mpBuffer[ mX ][ mY + 1 ] == -1 )
            {
                mpBuffer[ mX ][ ++mY ] = ++mValue;
                return    0;
            }
            return    -1;
        }
        int    ShiftUp()
        {
            if( ( mX - 1 ) >= 0 && mpBuffer[ mX - 1 ][ mY ] == -1 )
            {
                mpBuffer[ --mX ][ mY ] = ++mValue;
                return    0;
            }
            return    -1;
        }
        int    ShiftDown()
        {
            if( ( mX + 1 ) < mVertical && mpBuffer[ mX + 1 ][ mY ] == -1 )
            {
                mpBuffer[ ++mX ][ mY ] = ++mValue;
                return    0;
            }
            return    -1;
        }
        void    SetState( STATE::Enum rState )
        {
            mState = rState;
        }
        STATE::Enum GetState()
        {
            return    mState;
        }
        void    Print()
        {
            for( int i = 0 ; i < mVertical ; ++i )
            {
                for( int j = 0 ; j < mHorizon ; ++j )
                {
                    cout << mpBuffer[ i ][ j ] << "\t";
                }
                cout << endl;
            }
        }
};


int main( int argc , char** argv )
{
    int    vertical    = 6;
    int    horizon        = 6;
    int    ret = 0;

    Spiral    spiral( vertical , horizon );


    //spiral.Print();
    for( int i = 1 ; i < vertical * horizon ; ++i )
    {
        switch( spiral.GetState() )
        {
            case STATE::RIGHT:
                ret = spiral.ShiftRight();
                if( ret < 0 )
                {
                    spiral.SetState( STATE::DOWN );
                    spiral.ShiftDown();
                }
                break;
            case STATE::DOWN:
                ret = spiral.ShiftDown();
                if( ret < 0 )
                {
                    spiral.SetState( STATE::LEFT );
                    spiral.ShiftLeft();
                }
                break;
            case STATE::LEFT:
                ret = spiral.ShiftLeft();
                if( ret < 0 )
                {
                    spiral.SetState( STATE::UP );
                    spiral.ShiftUp();
                }
                break;
            case STATE::UP:
                ret = spiral.ShiftUp();
                if( ret < 0 )
                {
                    spiral.SetState( STATE::RIGHT );
                    spiral.ShiftRight();
                }
                break;
        }
    }
    spiral.Print();

}

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

풀이 작성

※ 풀이작성 안내
  • 본문에 코드를 삽입할 경우 에디터 우측 상단의 "코드삽입" 버튼을 이용 해 주세요.
  • 마크다운 문법으로 본문을 작성 해 주세요.
  • 풀이를 읽는 사람들을 위하여 풀이에 대한 설명도 부탁드려요. (아이디어나 사용한 알고리즘 또는 참고한 자료등)
  • 작성한 풀이는 다른 사람(빨간띠 이상)에 의해서 내용이 개선될 수 있습니다.
목록으로
코딩도장

코딩도장은 프로그래밍 문제풀이를 통해서 코딩 실력을 수련(Practice)하는 곳입니다.


언어별 풀이 현황
전 체 x 146
python x 45
기 타 x 17
java x 31
cpp x 35
cs x 6
javascript x 1
delphi x 1
go x 1
ruby x 2
lisp x 2
objectivec x 1
clojure x 1
scala x 3