Random Walk

'술취한 바퀴벌레' 문제라고도 한다. 다음과 같은 격자에 술취한 바퀴벌레가 있다고 해 보자

. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .

바퀴벌레는 임의의 한 점에서 시작하여서 임의의 방향으로 움직이게 된다. 이미 지나갔던 자리에 다시 갈 수 있으며 프로그램은 바퀴벌레가 각 위치에 몇번 갔는지 기억하여야 한다. 프로그램은 바퀴벌레가 모든 지점에 적어도 한번 이상 도달하였을 경우 끝난다. 바퀴벌레는 가로, 세로, 대각선으로 한칸 씩만 움직일수 있으며, 바퀴벌레가 움직이는 방향을 랜덤하게 만드는 것은 각자가 생각해 보도록 한다.

입력

격자의 가로, 세로 크기, 바퀴벌레의 초기 위치

출력

각 칸에 바퀴벌레가 멈추었던 횟수, 바퀴벌레가 움직인 횟수.

심화문제

격자의 가로, 세로의 크기를 입력받을때. 엄청나게 큰 크기를 입력하면 어떻게 할 것인가?


참고

출처: 위키백과

무작위 행보(無作爲行步, random walk, 랜덤 워크)는 수학, 컴퓨터 과학, 물리학 분야에서 임의 방향으로 향하는 연속적인 걸음을 나타내는 수학적 개념이다. 무작위 행보(random walk)라는 개념은 1905년 Karl Pearson이 처음 소개하였으며 생태학, 수학, 컴퓨터 과학, 물리학, 화학 등의 분야에서 광범위하게 사용되고 있다.

랜덤 워크는 시간에 따른 편차의 평균이 0이지만 분산은 시간에 비례하여 증가하게 된다. 따라서, 앞 뒤로 움직일 확률이 동일하다고 해도 시간이 흐름에 따라 평균에서 점차 벗어나는 경향을 보인다.

대표적인 예로는 브라운 운동이 있으며, "술고래의 걸음"이라고도 한다.

저 질문있어요^^; 출력에서 바퀴벌레가 움직인 횟수는 무엇을 말하는 것인가요?;ㅋㅋㅋ 혹시 바퀴벌레가 일직선으로 움직일때(들어온방향과 나간방향이 같을때) 바퀴벌레가 그 칸을 움직인거고, 그 칸에서 방향을 바꿨다면 그 칸에서 멈춘건가요? 각 칸에 바퀴벌레가 지나간 횟수가 최소화된다 뭐 이런 조건 없이 마음대로 랜덤하게 짜면 되는건가요? - Katherine, 2014/03/10 10:02 M D
@Katherine님, 바퀴벌레가 움직인 횟수는 바퀴벌레가 칸을 이동한 총 횟수이구요, 각 칸에 바퀴벌레가 멈추었던 횟수는 바퀴벌레가 몇번 그 칸에 들렀는지라고 보면 될것 같습니다. 네, 최소화 조건은 없구요, 바퀴벌레 자유의지에 의해서 랜덤하게 만드시면 됩니다. ^^ - 길가의풀, 2014/03/10 10:35 M D
@길가의풀 네 알겠어요^^ 감사합니다^^ - Katherine, 2014/03/10 11:05 M D
+1 Programming Challenge 자체가 현재 판매중인 프로그래밍 문제 책이고 사이트는 그 책의 문제들을 채점해볼 수 있는 공간을 제공하기 위한 것 아닌가요? 저작권 문제가 되지 않을지? - Kim Jaeju, 2014/03/10 13:55 M D
@Kim Jaeju 님, 아.. 저작권 문제가 될 수도 있을것 같네요, 생각도 못 해 봤는데요.. 저작권에 대해서는 잘 검토 해 보도록 하겠습니다. 알려주셔서 감사합니다. - 길가의풀, 2014/03/10 14:04 M D
@Kim Jaeju 님, Programming Challenge 저자(Miguel A. Revilla Ramos씨)에게 문의한 결과, Academic한 사용으로는 제한없이 사용할 수 있다는 답장을 받았네요 ^^. - 길가의풀, 2014/03/10 19:52 M D
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

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

import random

x, y, gps = input().split(' ')
x, y, gps = int(x), int(y), list(map(int,gps.split('.')))
_map = [0 for z in range(x*y)]
_list = [[a,b] for a in range(x) for b in range(y)]

while 0 in _map:
    a = random.randint(-1,1)
    b = random.randint(-1,1)
    if gps[0]+a == x or gps[0]+a < 0 or \
       gps[1]+b == y or gps[1]+b < 0:
        continue
    gps = [gps[0]+a,gps[1]+b]
    _map[_list.index(gps)] += 1
for a in [_map[a:a+x] for a in range(0,x*y,x)][::-1]:
    print(a)
print('총 움직인 횟수 : %d' % sum(_map))

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

심화는 .... 어렵워서 ㅠㅠ .... 100 * 100하는데 꾀 걸림 ㅠㅠ.

stay : 108 , move : 287

Board

17 38 35 13 1

27 19 15 7 2

28 13 11 3 1

11 14 4 4 2

1 4 4 1 3 계속하려면 아무 키나 누르십시오 . . .

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


void move(int* x, int* y);
bool verdict(int** arr);

int h, w;
int stay;
void main() { 
    srand(time(NULL));

    int init_x =0, init_y = 0;
    int x, y;
    x = init_x;
    y = init_y;
    h=5;
    w=5;
    stay = 0;
    //arr[y][x];
    int** arr = (int**) malloc (sizeof(int*) * h);
    for(int i=0;i<h;i++)
        arr[i] = (int*) malloc (sizeof(int*) * w);

    for(int i=0;i<h;i++)
        for(int j=0;j<h;j++)
            arr[i][j] = 0;

    while(!verdict(arr)) {
        move(&x, &y);
        arr[y][x]++;
    }
    int sum = 9;
    for(int i=0;i<h;i++)
        for(int j=0;j<h;j++)
            sum = sum + arr[i][j];
    printf("stay : %d , sum : %d\n", stay, sum);

    printf("\n\nBoard\n");
    for(int i=0;i<h;i++){
        for(int j=0;j<h;j++) {
            printf("%d\t", arr[i][j]);
        }
        printf("\n");
    }

}

bool verdict(int** arr) {
    for(int i=0;i<h;i++)
        for(int j=0;j<h;j++)
            if(arr[i][j]==0)
                return false;
    return true;
}

void move(int* x, int* y) {
    int d = rand()%8;
    int sx = *x, sy = *y;
    switch(d) {
        case 1:
            if(*y-1 >=0 && *x-1>=0) {
                (*y)--;
                (*x)--;
            }
            break;
        case 2:
            if(*y-1 >=0) 
                (*y)--;
            break;
        case 3:
            if(*y-1 >=0 && *x+1<w) { 
                (*y)--;
                (*x)++;
            }
            break;
        case 4:
            if(*x-1 >=0) 
                (*x)--;
            break;
        case 5:
            if(*x+1<w)
                (*x)++;
            break;
        case 6:
            if(*x-1 >=0  && *y+1 < h) {
                (*y)++;
                (*x)--;
            }
            break;
        case 7:
            if(*y+1 < h)
                (*y)++;
            break;
        case 8:
            if(*y+1 < h && *x+1 < w) {
                (*y)++;
                (*x)++;
            }
            break;
    }
    if(sx==*x && sy==*y)
        stay++;
}

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

늅늅입니다. 자바로 풀어봤습니다.

public static int sizeX;
    public static int sizeY;
    public static int mapCount;
    public static int moveCount;
    public static boolean[][] mapCheck;
    public static Random rand;
    public static int[] movePos;
    public static void main(String args[])
    {
        CreateMap(2000, 2000);
        Start();
    }

    public static void CreateMap(int x, int y)
    {
        sizeX = x; sizeY = y;

        mapCheck = new boolean[x][y];
        mapCount = x*y;
        moveCount = 0;
        movePos = new int[2];
        rand = new Random();

        for(int i = 0; i < x; i++) for(int j = 0; j <y; j++)
        {
            mapCheck[i][j] = false;
        }
    }

    public static void Start()
    {
        int moveX, moveY;

        moveX = 6; moveY = 5;

        mapCheck[moveX][moveY] = true;
        mapCount--;

        do 
        {
            movePos = RandMove(moveX, moveY);
            moveCount++;

            if(mapCheck[moveX][moveY] == false)
            {
                mapCheck[moveX][moveY] = true;
                mapCount--;
            }

            moveX = movePos[0];
            moveY = movePos[1];

            //System.out.println("바퀴가 " + moveX + ":" + moveY + "로 움직입니다." + " " + moveCount + " " + "아직 가보지 않은 방은 " + mapCount +"개 남았습니다."  );

        } while (mapCount != 0);

        Result();
    }

    public static int[] RandMove(int x, int y)
    {
        int moveTargetX, moveTargetY;

        moveTargetX = x;
        moveTargetY = y;

        int tempnum = rand.nextInt(3);
        switch(tempnum)
        {
        case 0:
            if(moveTargetX > 0)
                moveTargetX--;
            break;
        case 1:
            break;
        case 2:
            if(moveTargetX < sizeX-1)
                moveTargetX++;
            break;
        }

        tempnum = rand.nextInt(3);
        switch(tempnum)
        {
        case 0:
            if(moveTargetY > 0)
                moveTargetY--;
            break;
        case 1:
            break;
        case 2:
            if(moveTargetY < sizeY-1)
                moveTargetY++;
            break;
        }

        int[] targetPos = {moveTargetX, moveTargetY};

        movePos = targetPos;

        return movePos;
    }

    public static void Result()
    {
        System.out.println("바퀴가 움직인 횟수는 " + moveCount +"회 입니다.");
    }

제 컴퓨터에선 2000*2000 이 약 8~11초 정도 소요됩니다. 동선을 보기위해 주석을 푸니... ( ..)...

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

C#으로 작성했습니다. 위의 이우람 님의 코드를 도움 받아 작성했습니다. Random Walk가 아직도 이해하기 어렵네요. 추후에 다시 작성해서 올리겠습니다.

        public double CountRandomWalk(int m, int n)
        {

            var count = 0d;
            var enabled = new bool[m, n];
            var matrix = new int[m, n];
            var maxX = m - 1;
            var maxY = n - 1;
            var left = m*n;
            var random = new Random();
            var positionX = random.Next(0, m);
            var positionY = random.Next(0, n);

            while (true)
            {

                count++;
                matrix[positionX, positionY]++;
                if (!enabled[positionX, positionY])
                {
                    enabled[positionX, positionY] = true;
                    if (--left == 0) break;
                }

                if (positionX == 0) positionX += random.Next(0, 2);
                else if (positionX == maxX) positionX += random.Next(-1, 1);
                else positionX += random.Next(-1, 2);

                if (positionY == 0) positionY += random.Next(0, 2);
                else if (positionY == maxY) positionY += random.Next(-1, 1);
                else positionY += random.Next(-1, 2);

            }

            return count;
        }
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
# 파이썬 3.5.1

from random import *

def do(xl,yl,x,y):
    c = 0
    mat = [[0 for i in range(xl)] for i in range(yl)]
    direc = {0:(0,-1),1:(1,-1),2:(1,0),3:(1,1),4:(0,1),5:(-1,1),6:(-1,0),7:(-1,-1)}
    while True:
        matstr = ''
        matstt = ''
        for i in mat:
            i = list(map(str,i))
            matstt += ' ' + ' '.join(i) + ' \n'
            matstr += ' '.join(i) + '\n'
        if x == 1:
            if y == 1:
                di = choice([2,3,4])
            elif y == yl:
                di = choice([0,1,2])
            else:
                di = choice([0,1,2,3,4])
        elif x == xl:
            if y == 1:
                di = choice([4,5,6])
            elif y == yl:
                di = choice([6,7,0])
            else:
                di = choice([4,5,6,7,0])
        else:
            if y == 1:
                di = choice([2,3,4,5,6])
            elif y == yl:
                di = choice([0,1,2,6,7])
            else:
                di = choice([0,1,2,3,4,5,6,7])
        mat[x-1][y-1] += 1
        x += direc[di][0]
        y += direc[di][1]
        if matstt.count(' 0 ') == 0:
            return matstr,c
        c += 1

xM,yM,x,y = map(int,input().split())
s,c = do(xM,yM,x,y)
print(s)
print(c)
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
import random as rd
class cursor():
    def __init__(self, li, y, x):
        self.li, self.y, self.x = li, y, x
        self.li[y][x] += 1
        self.total = 0
    def get_movable(self):
        result = {'up':0, 'left':0, 'right':0, 'down':0}
        if self.y + 1 <= len(self.li) - 1:
            result['up'] = 1
        if self.x - 1 >= 0:
            result['left'] = 1
        if self.x + 1 <= len(self.li[0]) - 1:
            result['right'] = 1
        if self.y - 1 >= 0:
            result['down'] = 1
        return result
    def __next__(self):
        while 1:
            moves = self.get_movable()
            dy = rd.randint(-moves['down'],moves['up'])
            dx = rd.randint(-moves['left'],moves['right'])
            if dy == dx == 0: continue
            self.y += dy
            self.x += dx
            self.li[self.y][self.x] += 1
            self.total += 1
            if any(any(x == 0 for x in y) for y in self.li):
                continue
            else:
                break
        return self.li, self.total
    def print(self):
        for y in self.li:
            for x in y:
                print(x, end = ' ')
            print()
        print('\ntotal : '+str(self.total))
while __name__ == '__main__':
    m, n = list(map(int, input('>>>').split()))
    x, y = list(map(int, input('>>>>>>').split()))
    mp = list(list(0 for x in range(m)) for y in range(n))
    c = cursor(mp, y, x)
    next(c)
    c.print()

100*100에서 꽤 걸리네요. 파이썬 3.5.1

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

파이썬3.4입니다. 알고리즘이나 성능은 생각조차 못하고, 일단 출력되는데까지 했습니다.
제 컴이 문제인지(아니라면 더 비극ㅜ) maximum recursion depth exceeded 에러가 뜨길래, sys.setrecursionlimit를 늘려주면 된다고해서 일단 import해봤구요.
100x100이 뭔가요? 50x50만 해도 뻗어버리네요 ㅜㅜ
차후 실력이 늘거나 생각좀 해보고 수정해봐야겠네요..

from random import *
from pprint import *
import sys
sys.setrecursionlimit(10000000)
def f(x, y, walk = 0):
    global mtx
    def chk():
        for i in range(col):
            for j in range(row):
                if mtx[i][j] == 0:
                    return False
        return True
    if chk():
        return walk
    else:
        mtx[x][y] += 1
        a = randrange(-1, 2)
        b = randrange(-1, 2)
        while  x + a < 0 or x + a >= len(mtx) or y + b <0 or y + b >= len(mtx[0]):
            a = randrange(-1, 2)
            b = randrange(-1, 2)
        return f(x + a, y + b, walk + 1)
col, row = 30, 30 
x, y = 2, 3
mtx = [[0 for i in range(col)] for j in range(row)]
walk = f(x, y)
pprint(mtx)
print('walk', walk)

혹시 리스트가 느릴까봐, 모두 튜플로 바꿨고, 매트릭스는 좌표값을 키로, 방문횟수는 값으로 하여 딕셔너리로 했어요
매트릭스 딕셔너리를 셋으로 복사하여 방문한 곳은 셋에서 제거를 하면서 셋이 모두 비워질때까지 순환합니다.
100 x 100은 대략 2초 내외로 나오고, 300 x 300 이상도 많이 느리네요

'''
매트릭스를 딕셔너리로 구현. 혹시 리스트보다 빠를까봐
매트릭스의 키를 셋으로 복사하여, 한번 방문한 곳은 셋에서 제거함
모든 구역을 다 갔다면 셋이 {} 비어있음
'''
from random import randrange
from time import time

def make_matrix(col, row):
    matrix = {}
    for i in range(row):
        for j in range(col):
            matrix.update({(i, j): 0})
    return matrix

def walk(x, y):
    global matrix, matrix_set
    matrix[x, y] += 1
    matrix_set -= {(x, y)} #색인
    while True:
        dir_sel = DIR[randrange(8)]
        dir_sel_x, dir_sel_y = dir_sel[0], dir_sel[1]
        new_x, new_y = x + dir_sel_x, y + dir_sel_y
        if new_x < 0 or new_x >= col or new_y < 0 or new_y >= row:
            continue
        else:
            break
    return new_x, new_y

def start(x, y):
    a = time()
    chk = 0 #움직인 횟수
    while True:
        x, y = walk(x, y) 
        chk += 1
        if not matrix_set: #모두 방문하였으면
            break
    print(chk)
    print(matrix)
    b = time()
    print('time: %.2f' % (b - a))


col, row = 100, 100 
matrix = make_matrix(col, row)
matrix_set = set(matrix.keys())
DIR = (
    (-1, -1), (0, -1), (1, -1),
    (-1, 0), (1, 0),
    (-1, 1), (0, 1), (1, 1),
)

x, y = randrange(col), randrange(row)
start(x, y)

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

제 PC에서는 100X100 크기일 때 약 2~4초대에 결과가 나옵니다. (시작위치는 랜덤으로 했습니다.)

다음 위치를 고를 때 딱 한 번의 랜덤연산을 하기위해서 현 위치에서 갈 수 있는 위치를 모두 뽑은 다음, 그 중 하나를 랜덤으로 선택합니다. (3 ~7 개 중에서 하나를 고릅니다.) 한 번도 방문하지 않은 칸의 수를 별도 변수로 두고, 최초 방문하는 방이 있을 때마다 이 값을 감소시켜서 이 값이 0보다 큰 동안만 루프를 돌게 했습니다.

그런데 1000 X 1000 크기일 때는 너무 느려서 뭔가 다른 방법이 필요할 듯 합니다.

from random import randrange

def nextPos(i, _w, _h):
    _x = i % _w
    _y = i // _w
    ofs = [(_x + x, _y + y) for x in (-1, 0, 1) for y in (-1, 0, 1)
           if x*2 + y != 0 and 0 <= (_x + x) < w and 0 <= (_y + y) < _h]
    rx, ry = ofs[randrange(len(ofs))]
    return ry * w + rx

w = 100
h = 100
sx = randrange(w)
sy = randrange(h)

def main():
    data = [0] * (h * w)
    s = h * w
    m = 0
    p = sy * w + sx

    while s > 0:
        if data[p] is 0:
            s -= 1
        data[p] += 1
        p = nextPos(p, w, h)
        m += 1

    # print result
    print('move: ', m)
    print('\n'.join([' '.join(["{:03d}".format(data[x + y * w]) for x in range(w)]) for y in range(h)]))

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

Python 2.7

100*100은 약 1초 소요됩니다.

import random
d = zip([-1,-1,-1,0,0,1,1,1], [-1,0,1,-1,1,-1,0,1])
def walk(m, n, start=(0,0)):
    walkmat = [[0]*m for i in xrange(n)]
    posx = start[0]
    posy = start[1]
    unvisited = {(x,y) for x in xrange(m) for y in xrange(n)}-{(posx,posy)}
    walkmat[posy][posx]+= 1
    count = 0
    while unvisited:
        try:
            dx, dy = random.choice(d)
            assert 0 <= posx+dx < m
            assert 0 <= posy+dy < n
        except:
            continue
        posx+= dx
        posy+= dy
        walkmat[posy][posx]+= 1
        unvisited-= {(posx,posy)}
        count+= 1
    for y in xrange(n):
        for x in xrange(m):
            print walkmat[y][x],
        print
    print count
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

Ruby

  • array manipulation의 효율적 처리
  • tiles 검색/수정은 hash로, 처리완료 체크는 Set로.
  • visit 발생한 요소를 삭제해서 비교 횟수 줄이기. Set이 empty가 될 때 까지 반복
require 'set'

X, Y = 100, 100; matrix = [*1..Y].product([*1..X]).to_set
Tile = Struct.new :x, :y, :stay, :visit
tiles = matrix.map {|e| [e, Tile.new(e[0],e[1],0,0)] }.to_h
at = ->x,y { tiles[[x,y]] || false }

crawl = ->bug { n=at[bug[0]+rand(-1..1),bug[1]+rand(-1..1)]; n ? [n.x,n.y] : bug }
trail = ->prev,now { prev==now ? at[*prev].stay+=1 : at[*now].visit+=1 }
move = ->bug { crawl[bug].tap {|e| trail[bug,e]} }

bug=[rand(X)+1,rand(Y)+1]; (bug=move[bug]; matrix.delete(bug)) until matrix.empty?
puts "total movements : #{tiles.values.map(&:visit).reduce :+}"
tiles.each_slice(X).each {|cols| cols.each { |e|
              print "[%3d (%3d)] " % [e[1].stay, e[1].visit]}; print "\n" }

성능

# 100 x 100 화면출력 포함 : 1.5초. +-0.5초
Rehearsal -----------------------------------------------------
random walk :       1.200000   0.000000   1.200000 (  1.207901)
out to console :    0.010000   0.000000   0.010000 (  0.003795)
-------------------------------------------- total: 1.210000sec

                        user     system      total        real
random walk :       0.000000   0.000000   0.000000 (  0.000008)
out to console :    0.010000   0.000000   0.010000 (  0.003654)

output

#=> examle) 10x10. stays(visits)
total movements : 753
[ 0 ( 1)] [ 8 ( 5)] [ 0 ( 2)] [ 1 ( 2)] [ 2 ( 4)] [ 3 ( 4)] [ 0 ( 1)] [ 4 ( 8)] [10 ( 7)] [16 ( 8)]
[ 3 ( 6)] [ 0 ( 9)] [ 0 ( 3)] [ 1 ( 6)] [ 2 ( 8)] [ 0 ( 6)] [ 1 ( 7)] [ 0 (10)] [ 0 (18)] [ 4 (10)]
[ 7 ( 7)] [ 0 ( 9)] [ 1 ( 9)] [ 1 ( 3)] [ 1 ( 8)] [ 0 ( 6)] [ 2 ( 9)] [ 1 ( 8)] [ 2 ( 5)] [ 3 ( 4)]
[ 3 ( 4)] [ 2 (10)] [ 1 ( 6)] [ 0 ( 7)] [ 1 ( 6)] [ 0 ( 9)] [ 0 ( 6)] [ 1 (10)] [ 1 ( 5)] [ 5 ( 7)]
[ 2 ( 6)] [ 0 ( 8)] [ 0 ( 7)] [ 0 (10)] [ 0 ( 6)] [ 2 ( 7)] [ 2 ( 7)] [ 1 ( 6)] [ 2 ( 8)] [ 3 ( 9)]
[ 6 ( 9)] [ 0 (13)] [ 3 (15)] [ 1 ( 8)] [ 1 (11)] [ 1 ( 7)] [ 2 ( 5)] [ 0 ( 8)] [ 2 (10)] [ 8 ( 5)]
[ 1 ( 5)] [ 0 (17)] [ 0 ( 8)] [ 2 (14)] [ 2 ( 4)] [ 0 ( 5)] [ 0 ( 3)] [ 1 ( 8)] [ 3 (11)] [ 7 ( 7)]
[13 ( 7)] [ 3 (11)] [ 0 (14)] [ 2 (11)] [ 2 ( 5)] [ 0 ( 3)] [ 0 ( 3)] [ 0 ( 4)] [ 3 (11)] [ 7 ( 8)]
[ 1 (10)] [ 3 (20)] [ 3 (25)] [ 2 (11)] [ 0 ( 4)] [ 1 ( 5)] [ 4 ( 6)] [ 0 ( 3)] [ 0 ( 5)] [14 (10)]
[22 ( 9)] [15 (17)] [13 (13)] [ 4 ( 7)] [ 6 ( 4)] [ 3 ( 4)] [ 2 ( 6)] [ 5 ( 3)] [ 8 ( 3)] [ 1 ( 1)]
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

풀이 작성

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

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


언어별 풀이 현황
전 체 x 25
java x 3
python x 14
cpp x 1
기 타 x 2
matlab x 1
cs x 2
r x 1
ruby x 1