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 매트릭스에 나선형 회전을 한 값을 출력해야 한다.

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

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

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();

}

※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
private static void printSpiralArray(int n){

        int spiralArray[][] = new int[n][n];

        for(int i=0; i<n; i++){
            spiralArray[0][i] = i;  
        }

        int num = n;
        int xIndex = n-1;
        int yIndex = 0;
        int lotationCnt = 0;
        int loatationIndex = 1;
        String direction = "down";

        while(n-loatationIndex > 0){
            if(direction.equals("down")){
                for(int i=0; i<n-loatationIndex; i++){
                    spiralArray[++yIndex][xIndex] = num++;
                }
                direction = "left";
            }else if(direction.equals("left")){
                for(int i=0; i<n-loatationIndex; i++){
                    spiralArray[yIndex][--xIndex] = num++;
                }
                direction = "top";
            }else if(direction.equals("top")){
                for(int i=0; i<n-loatationIndex; i++){
                    spiralArray[--yIndex][xIndex] = num++;
                }
                direction = "right";
            }else if(direction.equals("right")){
                for(int i=0; i<n-loatationIndex; i++){
                    spiralArray[yIndex][++xIndex] = num++;
                }
                direction = "down";
            }
            lotationCnt++;

            if(lotationCnt%2==0){
                loatationIndex++;
            }
        }


        for(int i=0; i<n; i++){
            for(int j=0; j<n; j++){
                System.out.print(spiralArray[i][j] + " ");  
            }
            System.out.println();
        }
}

2017/04/07 20:50

yh

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

# 초기값
blank = -1
matrix = [[blank for w in range(0, width)] for h in range(0, height)]

# 커서
x, y = 0, 0

for idx in range(0, width * height):

    matrix[y][x] = idx

    # 다음위치 검색 (막힌곳과 열린곳 확인)

    check_top = y == 0 or matrix[y-1][x] != blank
    check_left = x == 0 or matrix[y][x-1] != blank
    check_bottom = y >= height-1 or matrix[y+1][x] != blank
    check_right = x >= width -1 or matrix[y][x+1] != blank

    if check_left and check_top and not check_right:
        x += 1
    elif check_top and check_right and not check_bottom:
        y += 1
    elif check_right and check_bottom and not check_left:
        x -= 1
    elif check_bottom and check_left and not check_top:
        y -= 1

for arr in matrix:
    print(arr)
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

include

include

define CoulumStart sheet->coulum[0]

define CoulumEnd sheet->coulum[1]

define RowStart sheet->row[0]

define RowEnd sheet->row[1]

define ENDFLAG sheet->putnum < sheet->endnum

define ARRY sheet->arry

int init;

typedef struct _sheet { int endnum; int putnum; int row[2]; int coulum[2]; int arry[100][100]; }Sheet;

void fcoulum_utod(Sheet sheet); void fcoulum_btot(Sheet sheet); void frow_rtol(Sheet sheet); void frow_ltor(Sheet sheet);

//////////////////////////////////////////////////////////////////////////////////////////////////

void frow_ltor(Sheet *sheet) { if (ENDFLAG) { for (int i = RowStart; i <= RowEnd; i++, sheet->putnum++) { printf("\nFUNTION %d\n", sheet->putnum); ARRY[CoulumStart][i] = sheet->putnum; } CoulumStart++;

    ////////////////////
    for (int i = 0; i < init; i++)
    {
        for (int j = 0; j < init; j++)
        {
            printf("%4d", sheet->arry[i][j]);
        }
        printf("\n");
    }
    /////////////////////
    fcoulum_utod(sheet);
}

}

void fcoulum_utod(Sheet *sheet) { if (ENDFLAG) { for (int i = CoulumStart; i <= CoulumEnd; i++, sheet->putnum++) { printf("\nFUNTION %d\n", sheet->putnum); ARRY[i][RowEnd] = sheet->putnum; } RowEnd--; //////////////////// for (int i = 0; i < init; i++) { for (int j = 0; j < init; j++) { printf("%4d", sheet->arry[i][j]); } printf("\n"); } ///////////////////// frow_rtol(sheet); } }

void frow_rtol(Sheet *sheet) { if (ENDFLAG) { for (int i = RowEnd; i >= RowStart; i--, sheet->putnum++) { printf("\nFUNTION %d\n", sheet->putnum); ARRY[CoulumEnd][i] = sheet->putnum; } CoulumEnd--; //////////////////// for (int i = 0; i < init; i++) { for (int j = 0; j < init; j++) { printf("%4d", sheet->arry[i][j]); } printf("\n"); } ///////////////////// fcoulum_btot(sheet); } }

void fcoulum_btot(Sheet *sheet) { if (ENDFLAG) { for (int i = CoulumEnd; i >= CoulumStart; i--, sheet->putnum++) { printf("\nFUNTION %d\n", sheet->putnum); ARRY[i][RowStart] = sheet->putnum; } RowStart++; //////////////////// for (int i = 0; i < init; i++) { for (int j = 0; j < init; j++) { printf("%4d", sheet->arry[i][j]); } printf("\n"); } ///////////////////// frow_ltor(sheet); } }

//////////////////////////////////////////////////////////////////////////////////////////////////

int main() { Sheet sheet;

printf("\n만들 배열의 크기를 입력하세요: ");
scanf("%d", &init);
if (init) printf("\n입력받은 숫자: %d", init);
else printf("\nINIT ERROR");

sheet.endnum = init * init;
sheet.putnum = 0;
sheet.row[0] = 0;
sheet.row[1] = init - 1;
sheet.coulum[0] = 0;
sheet.coulum[1] = init - 1;

for (int i = 0; i < init; i++)
{
    for (int j = 0; j < init; j++)
    {
        sheet.arry[i][j] = 0;
    }
    printf("\n");
}
printf("\nSUCCSED CLEAR\n");

frow_ltor(&sheet);

printf("\nSUCCSED FUNTION\n");

for (int i = 0; i < init; i++)
{
    for (int j = 0; j < init; j++)
    {
        printf("%4d", sheet.arry[i][j]);
    }
    printf("\n");
}

}

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

//#define SPIRAL_DEBUG

#ifdef SPIRAL_DEBUG
#define MEM_SHORTAGE_MSG                                                    \
    printf("[ERR] Memory shortage. %s %s %d",                               \
            __FILE__, __func__, __LINE__)

#define MEM_NULL_MSG                                                        \
    printf("[ERR] Memory points NULL status already. %s %s %d",             \
            __FILE__, __func__, __LINE__)
#else
#define MEM_SHORTAGE_MSG
#define MEM_NULL_MSG
#endif

static int *_create_array(size_t size);
static int _destroy_array(int **ppdel);

static int _input_data_in_spiral_array(int *parr, int col, int row,
        int start_num, int end_num, int start_cordi, int max_row);
static int _print_data_in_spiral_array(const int *parr,
        const int col, const int row);

///////////////////////////////////////////////////////////////////////////////

static int *_create_array(size_t size)
{
    int *pnew = (int *)malloc(size);
    if (pnew == NULL)
    {
        MEM_SHORTAGE_MSG;
        goto error;
    }

    memset((void *)pnew, 0x00, size);

    return pnew;

error :
    return NULL;
}

static int _destroy_array(int **ppdel)
{
    if (ppdel == NULL)
    {
        MEM_NULL_MSG;
        goto error;
    }

    if (*ppdel)
    {
        free((void *)*ppdel);
        *ppdel = NULL;
    }

    return 0;

error :
    return -1;
}

static int _input_data_in_spiral_array(int *parr, int col, int row,
        int start_num, int end_num, int start_cordi, int max_row)
{
    int i;
    int j;
    int k;

    int origin_col = col;
    int origin_row = row;

    j = k = start_cordi;

    /* The hightest row */
    for (i = 0; i < row; i++)
    {
        parr[j * max_row + k++] = start_num++;

        if (start_num >= end_num)
            return 0;
    }

    /* The rightest col */
    j++;
    k--;
    col--;
    for (i = 0; i < col; i++)
    {
        parr[j++ * max_row + k] = start_num++;

        if (start_num >= end_num)
            return 0;
    }

    /* The lowest row */
    j--;
    k--;
    row--;
    for (i = 0; i < row; i++)
    {
        parr[j * max_row + k--] = start_num++;

        if (start_num >= end_num)
            return 0;
    }

    /* The leftest col */
    j--;
    k++;
    col--;
    for (i = 0; i < col; i++)
    {
        parr[j-- * max_row + k] = start_num++;

        if (start_num >= end_num)
            return 0;
    }

    /* move start cordination */
    start_cordi++;

    if (start_num < end_num)
        _input_data_in_spiral_array(parr, origin_col - 2, origin_row - 2,
                start_num, end_num, start_cordi, max_row);

    return 0;
}

static int _print_data_in_spiral_array(const int *parr,
        const int col, const int row)
{
    int i;
    int j;

    printf("\n -------- array print -------- \n\n");
    for (i = 0; i < col; i++)
    {
        for (j = 0; j < row; j++)
            printf("%3d\t", parr[i * row + j]);

        printf("\n");
    }
    printf("\n");

    return 0;
}

int main(void)
{
    int row;
    int col;

    int *parr;

    scanf("%d %d", &col, &row);

    parr = _create_array(sizeof(int) * row * col);
    if (parr == NULL)
        goto error;

    if (_input_data_in_spiral_array(parr, col, row,
                0, col * row, 0, row) < 0)
        goto error;

    if (_print_data_in_spiral_array(parr, col, row) < 0)
        goto error;

    if (_destroy_array(&parr) < 0)
        goto error;

    return 0;

error :
    return -1;
}

c로 작성 했습니다. 저장하는 방식 말고 한번에 출력하는 방법으로 접근했는데 수식을 못 뽑아 내는 바람에 ㅠㅠ 코드는 저장하는 방식으로 구현한 내용입니다. 재귀를 썼는데 제법 까다롭네요 흠흠;;

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

풀이 작성

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

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


언어별 풀이 현황
전 체 x 142
java x 31
python x 44
cpp x 35
기 타 x 14
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