Eight Queens Problem

유명한 프로그래밍 퀴즈.

8-queens 문제는 Queen이 다른 Queen를 공격할 수 없는 8 X 8개의 체스 판에서 8개의 Queen을 체스판 위에 놓이게하는 문제이다. 체스 판에서 Queen은 똑같은 행렬(가로와 세로)/대각선방향에 대해서 공격이 가능하다. 그러므로 이 문제에 대한 solution은 자기 자신(Queen)을 보호하면서 새로운 위치에 Queen을 놓게 하는 것이다.

  1. 각 열에는 오직 하나의 퀸만 존재해야 한다.
  2. 각 행에는 오직 하나의 퀸만 존재해야 한다.
  3. 각각의 퀸의 대각선에 다른 퀸이 존재해서는 안 된다.

예를들어 다음과 같이 퀸을 위치할 수 있다.

8 x 8 체스판에 8개의 Queen을 놓을 수 있는 방법은 모두 몇 가지인가?

재귀호출
대각선도 행/열과 마찬가지로 한 퀸의 대각선 선상에서는 인접하지 않더라도 다른 퀸을 놓을 수 없다는거죠? 어휴 문제를 잘못 이해하고 풀었네요. 행,열과 달리 한 퀸과 바로 인접한 대각선방향에서만 퀸을 놓을 수 없는 걸로 이해하고 코드를 짰어요;ㅎㅎㅎ 나중에 시간나면 다시 풀어봐야겠네요 어릴 때 분명히 체스를 해 본 기억이 있는데.. 체스 룰이 기억이 잘 안나네요;;ㅎㅎ - Katherine, 2014/03/11 17:00 M D
@Katherine님, 네 맞습니다. 대각선상으로 움직일때도 부딫히면 안됩니다. - 길가의풀, 2014/03/11 17:18 M D
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

30개의 풀이가 있습니다. 3 / 3 Page

global count
count = 0

def copy(br):
    tmp = []
    for x in br:
        tmp.append(x[:])
    return tmp

def locate(b, co):
    br = copy(b)
    y, x = (co[0], co[1])
    if br[y][x] == 1:pass
    else:
        for i in range(8):
            br[i][x] = 1
            br[y][i] = 1
            for i in range(min(x,7-y)):br[y+i+1][x-i-1] = 1
            for i in range(min(x,y)):br[y-i-1][x-i-1] = 1
            for i in range(min(7-x,7-y)):br[y+i+1][x+i+1] = 1
            for i in range(min(7-x,y)):br[y-i-1][x+i+1] = 1
    return br

def newbr(li = []):
    br = li[:]
    if br == []:
        for i in range(8):
            br.append([])
            for j in range(8):
                br[i].append(0)
    return br

def n0(br, y):
    tmp = []
    if len(br[y]) == 0:return tmp
    for x in range(len(br[y])):
        if br[y][x] == 0:
            tmp.append(x)
    return tmp

def cal(br, depth = 0):
    l0 = n0(br, depth)
    if depth == 7:
        global count
        count += 1
        return
    for x in l0:
        tmp = copy(br)
        tmp = locate(tmp, (depth, x))
        if len(n0(tmp, depth+1)) != 0:
            cal(tmp, depth+1)

if __name__ == '__main__':
    board = newbr()
    cal(board)
    print('\n'+str(count))

분명 리스트를 복사했는데 레퍼런스 취급돼서 한동안 머리를 싸맸습니다. 알고보니 이중 리스트 [[],[],[]] 의 [], [], [] 이게 레퍼런스더군요;; 파이썬 3.5.1

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

첫 행부터 시작해서 0 ~ 7의 각 위치에 퀸이 있는 경우 그 아래 행들은 맨 위행의 퀸과 같은 열과 그 대각선 위치에는 퀸을 놓을 수 없습니다.

따라서 첫 행에 한 위치에 퀸을 놓고 그 아래 행들에서 퀸을 놓을 수 없는 위치를 표시한 후, 아래 행들에서는 놓을 수 있는 위치만 검사합니다. 이런 식으로 재귀로 작성했습니다.

from copy import copy

def check(avs=None,):
    if avs is None:
        avs = [[True] * 8 for _ in range(8)]
    result = 0
    if len(avs) is 0:
        return 1
    head, *tail = avs
    for a in range(8):
        if not head[a]:
            continue
        navs = [copy(l) for l in tail]
        for i, line in enumerate(navs):
            line[a] = False
            if (a - i - 1) >= 0:
                line[a - i - 1] = False
            if (a + i + 1) < 8:
                line[a + i + 1] = False
        result += check(navs)
    return result

%time print(check())
# 24ms
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

Ruby

row를 증가시키며 재귀로 탐색. valid로 걸러진 각각을 카운트.

valid = ->xy,x,y { xy.reject {|cx,cy| cx==x || cy==y || cx+cy==x+y || cx-cy==x-y } }
cnt = ->n,xy,r=1 { xy.select {|x,y|x==r}.sum {|e|r<n ? cnt[n,valid[xy,*e],r+1]:1 } }
queens = ->n,m=[*1..n] { cnt[n, m.product(m)] }

Test

expect(queens[2]).to eq 0
expect(queens[4]).to eq 2
expect(queens[6]).to eq 4
expect(queens[7]).to eq 40
expect(queens[8]).to eq 92
expect(queens[10]).to eq 724

# for performance
expect(Benchmark.realtime { queens[8] }).to be_between(0.001, 0.008)
                 user     system      total        real
8 Queens :   0.000000   0.000000   0.000000 (  0.006572)

Output

=> queens[8]
92
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
package main

import (
    "fmt"
    "sync"
)

type Board struct {
    data [8][8]int
    count int
}

func (b Board) Puttable(x, y int) bool {
    if x == 0 {
        return true
    }

    j := y
    k := y
    for i := x-1; i >= 0; i-- {
        j--
        k++
        if b.data[y][i] != 0 || (j >= 0 && b.data[j][i] != 0) || (k < 8 && b.data[k][i] != 0) {
            return false
        }
    }
    return true
}

func (b *Board) Set(x, y int) {
    b.data[y][x] = 1
}

func (b *Board) Clear(x, y int) {
    b.data[y][x] = 0
}

func (b *Board) Put(x, y int) bool {
    if b.Puttable(x, y) {
        b.Set(x, y)
        if x == 7 {
            b.count++
            b.Clear(x, y)
            return true
        }
    } else {
        return false
    }

    x++
    for i := 0; i < 8; i++ {
        b.Put(x, i)
        b.Clear(x, i)
    }

    return false
}

func main() {
    board := [8]Board{}
    count := 0
    ch := make(chan int)
    wg := sync.WaitGroup{}

    for i := 0; i < 8; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            board[i].Put(0, i)
            ch <- board[i].count
        }(i)
    }

    go func() {
        wg.Wait()
        close(ch)
    }()

    for c := range ch {
        count += c
    }

    fmt.Println(count)
}

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

Delphi 2010 으로 변환함. ( iljimae님의 코드 참조)

function fnFindEightQueens(C_Queens: Integer): Integer;

var cnt: Integer;

pos: array of Integer;

function chk(queen, rowpos: Integer): boolean;

var i, rowpos2: Integer;

begin

for i := 0 to queen - 1 do

begin

  rowpos2 := pos[i];

  if (rowpos2 = rowpos) or (rowpos2 = rowpos - (queen - i)) or (rowpos2 = rowpos + (queen - i)) then
    exit(False);

end;

result := true;

end;

procedure recur(x: Integer);

var i: Integer;

s: string;

begin

// if cnt > 0 then   //1개만 찾는 경우 
// Exit;

if (x = C_Queens) then

begin

  Inc(cnt);

  // Display 8 Queen Pos 
  // s := format('%2d: ', [cnt]); 
  // for i := 0 to C_Queens - 1 do 
  // s := s + format('%3d', [pos[i]]); 
  // Memo1.Lines.Add(s);

end

else

begin

  for i := 0 to C_Queens - 1 do

  begin

    if chk(x, i) then

    begin

      pos[x] := i;

      recur(x + 1);

    end;

  end;

end;

end;

begin

cnt := 0;

SetLength(pos, C_Queens + 1);

recur(0);

result := cnt;

end;

procedure TForm4.btnFind8QueenClick(Sender: TObject);

begin

Caption := IntToStr(fnFindEightQueens(8)); //8 Queens

end;

function fnFindEightQueens(C_Queens: Integer): Integer;
var
  cnt: Integer;
  pos: array of Integer;

  function chk(queen, rowpos: Integer): boolean;
  var
    i, rowpos2: Integer;
  begin
    for i := 0 to queen - 1 do
    begin
      rowpos2 := pos[i];
      if (rowpos2 = rowpos) or (rowpos2 = rowpos - (queen - i)) or (rowpos2 = rowpos + (queen - i)) then
        exit(False);
    end;
    result := true;
  end;

  procedure recur(x: Integer);
  var
    i: Integer;
    s: string;
  begin
    // if cnt > 0 then   //1개만 찾는 경우 
    // Exit; 
    if (x = C_Queens) then
    begin
      Inc(cnt);
      // Display 8 Queen Pos 
      // s := format('%2d: ', [cnt]); 
      // for i := 0 to C_Queens - 1 do 
      // s := s + format('%3d', [pos[i]]); 
      // Memo1.Lines.Add(s); 
    end
    else
    begin
      for i := 0 to C_Queens - 1 do
      begin
        if chk(x, i) then
        begin
          pos[x] := i;
          recur(x + 1);
        end;
      end;
    end;
  end;

begin
  cnt := 0;
  SetLength(pos, C_Queens + 1);
  recur(0);
  result := cnt;
end;

procedure TForm4.btnFind8QueenClick(Sender: TObject);
begin
  Caption := IntToStr(fnFindEightQueens(13));
end;
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

체스판 사이즈는 size 변수로 퀸의 수는 count 변수로 조정 가능 ex) count = -8 퀸 8개 , -7 퀸 7개

#include <stdio.h>
#include <stdlib.h>

int cal(int** board);
int putChessPiece(int** board, int x, int y);
int rChessPiece(int** board, int x, int y);
int size  = 8;
int count = -8;
int c = 0;
void main(void)
{
    int NoC = 0;

    int** board = (int**) malloc (sizeof(int*) * size);
    for(int i = 0;i< size; i++)
         board[i] = (int*) malloc (sizeof(int) * size);

    for(int i = 0;i< size; i++) 
        for(int j = 0;j< size; j++)
            board[i][j] = 0;


    NoC  = cal(board);
    printf("\n\n");
    printf("\n경우의 수 : %d\n", NoC);

}   

int cal(int** board) {

    for(int i = 0;i< size; i++) {
        for(int j = 0;j< size; j++) {
            if(board[i][j] > count && board[i][j] < 1) {
                putChessPiece(board, i, j) ;
                count++;
                int temp = 0;     // 0의 갯수
                for(int k = 0;k< size; k++) {
                    for(int l = 0;l< size; l++) {
                        if(board[k][l] == 0) 
                            temp++;
                    }
                }

                if(temp  != 0) {   // 0의 갯수가 하나라도 존재 할 때
                    cal(board); 
                }

                if(count == 0) {
                    c++;
                }
                count--;

                rChessPiece(board, i, j);
            }
        }
    }
    for(int i = 0;i< size; i++) {
        for(int j = 0;j< size; j++) {
            if(board[i][j] == count)
                board[i][j] = 0;
        }
    }
    return c;
}

int rChessPiece(int** board, int x, int y) {

    for(int i = 0;i< size; i++) {
        for(int j = 0;j< size; j++) {
            if( x == i && board[i][j] > 0) {
                board[i][j]--;
            }
            if( y == j && board[i][j] > 0) {
                board[i][j]--;
            }
            if( (y-j) == (x-i) && board[i][j] > 0) {
                board[i][j]--;
            }
            if( (y-j) == (i-x) && board[i][j] > 0) {
                board[i][j]--;
            }
        }
    }
    board[x][y] = count;
    return 0;
}

int putChessPiece(int** board, int x, int y) {  
    for(int i = 0;i< size; i++) {
        for(int j = 0;j< size; j++) {
            if( x == i && board[i][j] >= 0) {
                board[i][j]++;
            }
            if( y == j && board[i][j] >= 0) {
                board[i][j]++;
            }
            if( (y-j) == (x-i) && board[i][j] >= 0) {
                board[i][j]++;
            }
            if( (y-j) == (i-x) && board[i][j] >= 0) {
                board[i][j]++;
            }
        }
    }
    board[x][y] = count;
    return 0;
}
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
#include <stdio.h>

#define SIZE 8
#define QUEEN 9
#define NONE 0

int s = 0;

void clearBoard(int board[SIZE][SIZE]) {
    for(int i = 0; i < SIZE; i++) {
        for(int j = 0; j < SIZE; j++) {
            board[i][j] = 0;
        }
    }
}
void printBoard(int board[SIZE][SIZE]) {
    printf("\nNo.%d\n+",s);
    for(int i = 0; i < SIZE; i++) {
        printf("-+");
    }
    printf("\n");
    for(int i = 0; i < SIZE; i++) {
        printf("|");
        for(int j = 0; j < SIZE; j++) {
            switch(board[i][j]) {
                case QUEEN:
                    printf("Q|");
                    break;
                case NONE:
                    printf(" |");
                    break;
                default:
                    printf(".|");
                    break;
            }
        }
        printf("\n+");
        for(int i = 0; i < SIZE; i++) {
            printf("-+");
        }
        printf("\n");
    }
}
int putQueen(int row, int board[SIZE][SIZE]) {
    int leftCol, rightCol;
    for(int col = 0; col < SIZE; col++) {
        if(board[row][col] == 0) {
            if(row < SIZE) {

                board[row][col] = QUEEN;            
                leftCol = col, rightCol = col;
                for(int nextRow = row + 1; nextRow < 8; nextRow++) {
                    board[nextRow][col]++;
                    if(leftCol > 0)
                        board[nextRow][--leftCol]++;
                    if(rightCol < SIZE - 1)
                        board[nextRow][++rightCol]++;
                }

                putQueen(row + 1, board);

                board[row][col] = NONE;
                leftCol = col, rightCol = col;
                for(int nextRow = row + 1; nextRow < 8; nextRow++) {
                    board[nextRow][col]--;
                    if(leftCol > 0)
                        board[nextRow][--leftCol]--;
                    if(rightCol < SIZE - 1)
                        board[nextRow][++rightCol]--;
                }
            } else {
                s++;
                board[row][col] = QUEEN;
                printBoard(board);
                board[row][col] = NONE;     
            }
        }
    }
}

int main(){
    int board[SIZE][SIZE];
    clearBoard(board);  
    putQueen(0, board);
}
.....
생략
.....
No.90
+-+-+-+-+-+-+-+-+
| | | | | | | |Q|
+-+-+-+-+-+-+-+-+
| |Q| | | | |.|.|
+-+-+-+-+-+-+-+-+
|.|.|.| |Q|.| |.|
+-+-+-+-+-+-+-+-+
| |.|Q|.|.|.| |.|
+-+-+-+-+-+-+-+-+
|Q|.|.|.|.| |.|.|
+-+-+-+-+-+-+-+-+
|.|.|.| |.|.|Q|.|
+-+-+-+-+-+-+-+-+
|.|.|.|Q|.|.|.|.|
+-+-+-+-+-+-+-+-+
|.|.|.|.|.|Q|.|.|
+-+-+-+-+-+-+-+-+

No.91
+-+-+-+-+-+-+-+-+
| | | | | | | |Q|
+-+-+-+-+-+-+-+-+
| | |Q| | | |.|.|
+-+-+-+-+-+-+-+-+
|Q|.|.|.| |.| |.|
+-+-+-+-+-+-+-+-+
|.|.|.| |.|Q| |.|
+-+-+-+-+-+-+-+-+
|.|Q|.|.|.|.|.|.|
+-+-+-+-+-+-+-+-+
|.|.|.|.|Q|.|.|.|
+-+-+-+-+-+-+-+-+
|.|.|.|.|.|.|Q|.|
+-+-+-+-+-+-+-+-+
|.|.|.|Q|.|.|.|.|
+-+-+-+-+-+-+-+-+

No.92
+-+-+-+-+-+-+-+-+
| | | | | | | |Q|
+-+-+-+-+-+-+-+-+
| | | |Q| | |.|.|
+-+-+-+-+-+-+-+-+
|Q| |.|.|.|.| |.|
+-+-+-+-+-+-+-+-+
|.|.|Q|.|.|.| |.|
+-+-+-+-+-+-+-+-+
|.|.|.|.| |Q|.|.|
+-+-+-+-+-+-+-+-+
|.|Q|.|.|.|.|.|.|
+-+-+-+-+-+-+-+-+
|.|.|.|.|.|.|Q|.|
+-+-+-+-+-+-+-+-+
|.|.|.|.|Q|.|.|.|
+-+-+-+-+-+-+-+-+

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

파이썬3.5
1. N x N board를 만들고, chk(board) 하면 최초 라인의 퀸을 놓을 수 있는 좌표(ij)를 튜플들을 리턴한다.
2. 반환된 튜플들을 fill(board, ij)로 1로 표시하고 가로,세로,대각선은 'x'로 표시한다.
3. 빈공간이 없을때까지 1, 2번을 반복한다.
4. board의 숫자합이 N 이 되면 1을 리턴하고, 그렇지 않으면 0을 리턴한다.
5. 리턴값을 더한값이 답이다.

import copy

def chk(board):

    ij = []
    for (i, line) in enumerate(board):
        for (j, x) in enumerate(line):
            if x == 0:
                ij.append((i, j))
        if ij:
            return ij


def fill(board_, ij):

    board = copy.deepcopy(board_)
    i, j = ij
    for x in range(N):
        board[i][x] = 'x'
    for y in range(N):
        board[y][j] = 'x'

    for n in range(1, N):
        if i-n >= 0 and j-n >= 0:
            board[i-n][j-n] = 'x'
        if i-n >= 0 and j+n < N:
            board[i-n][j+n] = 'x'
        if i+n < N and j-n >= 0:
            board[i+n][j-n] = 'x'
        if i+n < N and j+n < N:
            board[i+n][j+n] = 'x'

    board[i][j] = 1

    return board


def f(board):

    if not any(0 == x for line in board for x in line):
        if sum(x for line in board for x in line if type(x) != str) == N:
            return 1
        else:
            return 0

    return sum(f(fill(board, ij)) for ij in chk(board))


N = 8
board = [[0] * N for _ in range(N)]
print(f(board))
# 92
# 1 loop, best of 3: 245 ms per loop
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

전형적인 백트래킹 문제. Edgar Dijkstra의 알고리즘을 그대로 C로 옮기면 아래와 같음.

#include <stdio.h>

int count = 0;

int cols[8] = {0};
int lr[15] = {0};
int rl[8] = {0};

void eq(int row) {
    if (row == 8) {
        count++;
        return;
    }
    for (int col = 0; col < 8; col++) {
        if (cols[col] || lr[7 + row - col] || rl[row + col])
            continue;

        // take step
        cols[col] = 1;
        lr[7 + row - col] = 1;
        rl[row + col] = 1;

        eq(row + 1);

        // step back
        lr[7 + row - col] = 0;
        rl[row + col] = 0;
        cols[col] = 0;
    }
}

int main(int argc, const char * argv[]) {
    eq(0);
    printf("%d\n", count);
    return 0;
}

차근차근 접근한다면.. 각 row에는 여왕 하나만 놓을 수 있으므로, 첫 줄부터 여왕을 놓아서 8번째 줄까지 문제없이 여왕을 놓을 수 있으면 솔루션 하나가 됨.

뼈대


void bt(int row) {
  if (row == 8) { // 8줄 모두 놓았으니 끝.
    count++;
    return;
  }
  // 현재 row에 새로운 여왕을 놓아야 하는데 
  // 모든 col에 대해 놓을 수 있는지 검사하고, 놓을 수 있으면 다음 줄로 진행..

  for (int col=0; col<8; col++) {
    if (현재 row의 col위치에 여왕을 놓을 수 있으면) {
      bt(row+1);
    }
  }
}

bt(0); // 0부터 시작

한 줄에 하나만 놓으므로 같은 row에서 여왕들이 충돌할 일은 없므르로, 0~row-1 까지 이미 놓아둔 여왕들과

  • 같은 col에서 충돌이 있는지
  • 좌상-우하 방향의 대각방향에 충돌이 있는지
  • 우상-좌하 방향의 대각방향에 충돌이 있는지..

위 세가지 충돌이 없으면 현재 row의 col위치에 여왕을 놓을 수 있고, 다음 줄로 진행할 수 있음.

그러므로 여왕을 놓을 때마다 충돌검사를 위한 배열에 플래그를 지정함.

int cols[8] = {0, }; // col에 놓을 때 1로 설정
int lr[15] = {0, }; // 좌상-우하 방향의 대각방향.. (row, col)을 지나는 직선의 y절편.. (기울기 1)
int rl[15] = {0, }; // 우상-좌하 방향의 대각방향.. (row, col)을 지나는 직선의 y절편.. (기울기 -1)

그러면 for에선..

  for (int col=0; col<8; col++) {
    if (cols[col] || lr[7 + row - col] || rl[row + col])  // 이미 놓였으므로..
      continue; // 더이상 진행할 필요없음

    // 현재 col에 놓을 수 있음.
    cols[col] = 1;
    lr[7 + row - col] = 1;
    rl[row + col] = 1;

    bt(row+1); // 이제 다음 줄로 넘어감..

    // 다음 col을 확인하기 전에 아까 설정한 값 reset!

    cols[col] = 0;
    lr[7 + row - col] = 0;
    rl[row + col] = 0;
  }
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
#!/usr/bin/python3

import copy

class Board():
    col = 8
    row = 8

    def __init__(self):
        self.board = [[None for col in range(self.row)] for j in range(self.col)]
        self.queen_arr = []

    def __str__(self):
        s = ''
        for c in range(self.col):
            for r in range(self.row):
                if self.board[c][r] == 2:
                    s += "%4s " % 'Q'
                else:
                    s += "%4s " % self.board[c][r]
            s += '\n'
        return s

    def clean(self):
        self.board = [[None for col in range(self.row)] for j in range(self.col)]

    def ableQ(self,col,row):
        col -= 1
        row -= 1
        if self.board[col][row] == None:
            return True
        else :
            return False

    def queen(self, col, row):
        if (col < 1 or col > 9) or (row < 1 or row > 9):
            return False
        col -= 1
        row -= 1

        for i in range(8):
            self.board[col][i] = 1
            self.board[i][row] = 1

        for i in range(8):
            if col+i > 7 or row+i > 7:
                break
            self.board[col+i][row+i] = 1

        for i in range(8):  
            if col-i < 0 or row-i < 0:
                break
            self.board[col-i][row-i] = 1

        for i in range(8):
            if col-i < 0 or row+i > 7:
                break
            self.board[col-i][row+i] = 1

        for i in range(8):
            if col+i > 7 or row-i < 0:
                break
            self.board[col+i][row-i] = 1


        self.queen_arr.append(str(col)+str(row))
        self.queen_set()

        return True

    def queen_set(self):
        for arr in self.queen_arr:
            self.board[int(arr[0])][int(arr[1])] = 2

def queen_recursive(board,num):
    b = None
    count = 0
    for i in range(1,9):
        b = copy.deepcopy(board)
        if b.ableQ(num,i):
            b.queen(num,i)
            if num > 1 :
                count += queen_recursive(b,num-1)
            else:
                count += 1
    return count

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

풀이 작성

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

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

재귀호출 x 3
연관 문제
길가의풀, 2016/12/19 11:18
주 현태, 2017/01/01 19:56

언어별 풀이 현황
전 체 x 30
java x 3
python x 12
lisp x 1
기 타 x 4
go x 1
cpp x 6
ruby x 2
cs x 1