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
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

31개의 풀이가 있습니다. 1 / 4 Page

파이썬 3.4 입니다. 심화문제는 나중에 생각해 봐야겠습니다. 100*100 격자만 되어도 많이 느려지네요. 많이 부족하지만 올려봅니다.

예를 들어, 격자의 가로는 3, 세로는 4 이고 초기 위치가 (2, 1) 라고 가정해 봅니다. 각 격자의 각 셀의 위치를 x,y 좌표를 기반으로 표시합니다. 각 위치에 해당하는 방문횟수를 stop_count 라는 리스트 형태로 작성해 보았습니다.

첫째로, 현재의 위치 정보 (2, 1) 을 받아들여 stop_count[1][0] 에 +1 을 합니다.

둘째로, 임의로 한칸 움직일 방향을 정합니다 (아래 코드의 __get_direction 함수). random 모듈의 randrange 를 이용하였고, x / y 축에 대해 각각 (-1, 0, 1) 사이의 값을 고르도록 했습니다. 단 위치에 따라 움직임에 제약생기는 부분을 고려하면, 위치 값이 1 인 경우는 (0, 1) 중에서, 최대값 ( x=3, or y=4 ) 이면 (-1, 0) 중에서 선택하도록 했습니다. 그리고, 선택한 값이 (0, 0) 이 되면 다시 선택하도록 했습니다.

셋째로, 움직임 방향이 정해지면 실제로 움직여서 새로운 위치정보를 얻습니다. 이때 움직인 횟수를 하나 더해줍니다. 그리고 다시 현재 위치 정보를 받아들여서 stop_count 리스트에 반영합니다.

이제, stop_count 리스트의 모든 값이 0 이 아닌지 확인합니다 (아래 코드의 __check_stop_by 함수). 만약 0이 있으면 전체 과정을 반복합니다.

아래는 Output 의 한 예 입니다.

The number of total movement is 36.

The matrix below is the number of visit to each cell.

1 3 3
2 4 3
1 5 5
2 4 4

from random import randrange

class RoachMatrix:
    def __init__(self,matrix_size,position):
        self.matrix_size = matrix_size
        self.x = self.matrix_size[0]; self.y =self.matrix_size[1]
        self.position = position
        self.stop_count = []
        for i in range(self.x):
            y_array = [0]*self.y
            self.stop_count.append(y_array)
        x = self.position[0]-1; y = self.position[1]-1
        self.stop_count[x][y] = 1
        self.all_stop_by = False
        self.total_move = 0

    def __get_direction(self):
        direction = [0,0]
        while direction == [0,0]:
            for i in range(2):
                if self.position[i] == 1: direction[i] = randrange(0,2)
                elif self.position[i] == self.matrix_size[i]: direction[i] = randrange(-1,1)
                else: direction[i] = randrange(-1,2)
        return direction

    def __check_stop_by(self):
        result = True
        for i in self.stop_count:
            if all(j for j in i) == False:
                result = False
                return result
        return result

    def record_move(self):
        while self.all_stop_by == False:
            direction = self.__get_direction()
            for i in range (2):
                self.position[i] = self.position[i] + direction[i]
            self.total_move += 1
            x = self.position[0]-1; y = self.position[1]-1
            self.stop_count[x][y] = self.stop_count[x][y] + 1
            self.all_stop_by = self.__check_stop_by()
        print("The number of total movement is %d.\n"%self.total_move)

    def print_stop_count(self):
        print("The matrix below is the number of visit to each cell.\n")  
        for i in range(self.y-1,-1,-1):
            line = ''
            for j in range(self.x):
                temp_count = str(self.stop_count[j][i])+'\t'
                line = line + temp_count
            print(line)            

matrix_size = [3,4]
start_pos = [2,1]

a = RoachMatrix(matrix_size,start_pos)
a.record_move()
a.print_stop_count()
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

Python 3.4 입니다. 좌표값을 사전으로 처리하는 방법을 사용하였습니다. 100*100 수행시 제 컴퓨터에서 약 1초 정도 소요되네요(36만번 이동)

import random
import itertools
import time

DIRECTION = list(itertools.product((-1, 0, 1), repeat=2))
DIRECTION.remove((0, 0))


def roach(xsize, ysize, xpos, ypos):
    matrix = {}
    pos = (xpos, ypos)
    count = 0
    while len(matrix) < xsize * ysize:
        matrix[pos] = matrix.get(pos, 0) + 1
        count += 1
        while True:
            tempdir = random.choice(DIRECTION)
            temppos = (pos[0] + tempdir[0], pos[1] + tempdir[1])
            if -1 < temppos[0] < xsize and -1 < temppos[1] < ysize: break
        pos = temppos
    return count, matrix

if __name__ == '__main__':
    t=time.time()
    xsize, ysize, xpos, ypos = 100, 100, 0, 0
    r= roach(xsize,ysize,xpos,ypos)
    print(r[0])
    print(time.time()-t)
    for i in range(ysize):
        print(' '.join(['{0:3}'.format(str(r[1][(j,i)])) for j in range(xsize)]))
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

C# 입니다.

const int X = 100, Y = 100;
const int BOUNDX = X - 1, BOUNDY = Y - 1;        

bool[,] isPassPos = new bool[X, Y];
int[,] numPassPos = new int[X, Y];
int remainPosCount = X * Y;

Random rnd = new Random();
int posX = rnd.Next(0, X);
int posY = rnd.Next(0, Y);                        
double moveCount = 0;

while (true)
{
    moveCount++;
    numPassPos[posX, posY]++;

    if (!isPassPos[posX, posY])
    {
        isPassPos[posX, posY] = true;
        if (--remainPosCount == 0) break;
    }

    switch (posX)
    {
        case 0: posX += rnd.Next(0, 2); break;
        case BOUNDX: posX += rnd.Next(-1, 1); break;
        default: posX += rnd.Next(-1, 2); break;
    }
    switch (posY)
    {
        case 0: posY += rnd.Next(0, 2); break;
        case BOUNDY: posY += rnd.Next(-1, 1); break;
        default: posY += rnd.Next(-1, 2); break;
    }
}

Console.WriteLine("MoveCount : " + moveCount);

C#의 경우는 100 x 100을 실행하는데에는 20밀리초 정도가 걸립니다.C#의 기본 난수 발생은 Donald E. Knuth의 감산 알고리즘, 파이썬은 메르센 트위스터가 기본 알고리즘이라고 하네요. 아마 랜덤의 생성에서 대부분의 시간이 차이나는걸로 보입니다. 저도 단순 무식한 방법으로 했구요, 남아있는 위치의 카운트 변수를 추가적으로 만들어 마지막을 체크했습니다. 문제엔 꼭 다음 스텝에 이동을 해야한다는 조건이 없기때문에, 방향 백터가 0,0이 나오는 경우도 있습니다. 그래서 그 자리에 그대로 머물러 있는 경우도 카운트에 포함됩니다. 총 이동 카운트는 20 ~ 50만까지 다양하게 찍힙니다.

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

제 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()
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
walk = function(mat, row, col, n){
  mat[row,col]=mat[row,col]+1
  if(row>1 && row<nrow(mat)){    v.row=(row-1):(row+1)
  } else if(row>1) { v.row=(row-1):row
  } else if(row<nrow(mat)) { v.row=row:(row+1)
  } else {v.row=row}
  if(col>1 && col<ncol(mat)){ v.col=(col-1):(col+1)
  } else if(col>1) { v.col=(col-1):col
  } else if(col<ncol(mat)) { v.col=col:(col+1)
  } else {v.col=col}
  repeat{
    sample.row=sample(v.row, 1)
    sample.col=sample(v.col, 1)
    if(!((sample.row==row) && (sample.col==col))) {row<<-sample.row; col<<-sample.col; break} 
  }
  return(mat)
}
row=1
col=1
matt=matrix(0, 100, 100)
system.time(repeat{
    matt=walk(matt, row, col)
    if(all(matt>0)==T) {cat("완료\n") ; print(matt) ; print(sum(matt)); break}
  }
)

R로 무식하게 짜봤습니다.

모든 값이 0인 행렬을 생성하고 해당 위치에 바퀴벌레가 올 경우 +1을 해주며 모든 값이 0보다 클 경우 현재 행렬과 움직인 회수를 출력합니다. 바퀴벌레의 이동은 각 행과 열에 대해 if문으로 범위를 정하고 임의로 정하며 제자리에 있는 경우는 제외했습니다. 마지막으로 재귀함수를 통해 모든 칸이 채워질 때까지 반복했습니다.

만일 격자가 매우 클 경우 바퀴벌레의 이동횟수는 격자 크기에 대해서 기하급수적으로 증가하기 때문에 계산이 오래 걸리고 컴퓨터 사양에 많이 의존할 것 같네요.. 실제로 R 코드에서는 재귀 호출에 한계가 있는지 10x10 정도의 격자가 한계더군요.

수정: 코드가 지저분해 졌지만 재귀 호출을 하지 않도록 해보았습니다. 100x100격자에 34만번 이동이 90초 정도 걸리는 듯 합니다

system.time(repeat{
    matt=walk(matt, row, col)
    if(all(matt>0)==T) {cat("완료\n") ; print(matt) ; print(sum(matt)); break}
  }
)
[1] 346112
 사용자  시스템 elapsed 
  90.90    0.03   92.29 
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.

지뢰찾기랑 거의 동일하게 만들었습니다.

바퀴를 스타트 지점에 위치시킨 후 0~7 까지의 랜덤한 수를 받아서 그 수에 해당되는 방향으로 계속 이동시키고 이동시킬 때마다 카운트를 올립니다. 그리고 카운트가 0 인 위치(Square)가 없을 때까지 계속 이동시킵니다. 바퀴가 모든 위치를 거쳤다면 그 결과를 출력시킵니다.

100 x 100 인 경우, 경우에 따라서 다르지만 제 PC에서는 421,503번 이동에 50초가량 걸리네요. 술취한 바퀴벌레는 무조건 랜덤이기 때문에 어떤식으로 최적화가 가능할지는 생각해 봐야겠습니다.


파이썬입니다.

# -*- coding: utf-8 -*-
import unittest
import random


class Square:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.value = 0

    def __str__(self):
        return "%s\t" % self.value


class Matrix:
    direction = [
        (-1,-1),(0,-1),(1,-1),
        (-1,0),(+1, 0),
        (-1,+1),(0,+1),(1,+1),
    ]
    def __init__(self, m, n):
        self.map = []
        for y in range(n):
            cols = []
            for x in range(m):
                square = Square(x, y)
                cols.append(square)
            self.map.append(cols)

    def getSquare(self, x, y):
        if 0 <= x < len(self.map[0]) and 0 <= y < len(self.map):
            return self.map[y][x]
        else:
            return None

    def isWalkAll(self):
        for row in self.map:
            for square in row:
                if square.value == 0: return False
        return True

    def getNextSquare(self, square):
        d = self.direction[random.randint(0,7)]
        next = self.getSquare(square.x+d[0], square.y+d[1])
        if not next: return self.getNextSquare(square)
        else: return next

    def start(self, x, y):
        square = self.getSquare(x, y)
        square.value += 1
        next = square
        while not self.isWalkAll():
            next = self.getNextSquare(next)
            next.value += 1

    def reveal(self):
        total = 0
        result = []
        for row in self.map:
            for square in row:
                result.append(str(square))
                total += square.value
            result.append("\n")
        return "".join(result).strip(), total


class RoachTest(unittest.TestCase):
    def test1(self):
        matrix = Matrix(4, 7)
        matrix.start(0, 0)
        m, total = matrix.reveal()
        print m
        print '-' * 70
        print "Total movement: %s" % total


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

Python 2.7.6

프래그래밍 초보입니다. 어떠한 피드백도 환영합니다.

# -*- coding: cp949 -*-

import random

class Result: # 결과 객체용 클래스
    tile = [] # 각 타일별 벌레가 멈추었던 횟수를 저장하는 2차원 배열
    count = 0 # 바퀴벌레가 총 움직인 횟수

def bug_run(m, n, cood):
    tile = [[0 for i in xrange(n)] for j in xrange(m)] # 타일별 멈춘 횟수 초기값 0으로 세팅하여 생성
    tile[cood[0]][cood[1]] = 1 # 일단 시작 위치에도 멈춘 횟수 1을 줌
    new_cood = [] # 편의상 임시 변수(벌레의 이동 후의 새로운 좌표를 나타냄)
    count = 0 # 총 이동 횟수 저장용 변수

    while 1:

        while 1:
            random_dx = random.choice((-1, 0, 1,))
            random_dy = random.choice((-1, 0, 1,))
            new_cood = [cood[0]+random_dx, cood[1]+random_dy] # 벌레를 랜덤 이동시킴

            if not(random_dx == 0 and random_dy == 0): # 랜덤 이동의 유효성을 평가
                if new_cood[0] > -1 and new_cood[0] < m and new_cood[1] > -1 and new_cood[1] < n:
                    count = count + 1
                    break # 유효한 이동이 나오면 랜덤화 중단

        cood = [new_cood[0], new_cood[1]] # 실제로 벌레를 이동 시킴
        tile[cood[0]][cood[1]] = tile[cood[0]][cood[1]] + 1 # 이동한 타일에 대하여 멈춘 횟수를 업데이트

        trigger = True # 루프 종료 조건용 변수

        for i in xrange(m):
            if 0 in tile[i]:
                trigger = False # 각 타일에 멈춘 횟수 0이 하나라도 있으면 종료 불가

        if trigger:
            break

    result = Result()
    result.tile = tile
    result.count = count

    return result

# 테스트

bug_test = bug_run(6, 6, [3, 3])

for i in bug_test.tile:
    print i

print "Total Count: %d" % (bug_test.count)

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

파이썬입니다~ 바퀴벌레의 위치는 랜덤으로 입력되도록 했습니다. 바퀴벌레 위치는 cock_map에 바퀴벌레가 이동하면서 머문 횟수는 stack_map에 기록했습니다. cnt는 바퀴벌레가 이동한 횟수입니다~

class Roach:
    def __init__(self,a,b):
        self.mp = [[0 for i in range(b)] for x in range(a)]
        self.a = a
        self.b = b # a,b,mp을 글로벌 변수로 지정

    def start(self):
        from random import choice
        from random import randrange
        import copy

        cock_map = self.mp
        stack_map = copy.deepcopy(cock_map) # 딥카피로 리스트 내부까지 카피
        cnt = 0  

        pin_a = randrange(0,self.a)
        pin_b = randrange(0,self.b)
        cock_map[pin_a][pin_b] = "*"
        stack_map[pin_a][pin_b] += 1

        cont = True
        while cont:
            lst = [-1,0,1]
            temp_a = 0
            temp_b = 0
            temp_a = pin_a + choice(lst)
            temp_b = pin_b + choice(lst)
            if temp_a < 0 or temp_a >= self.a or temp_b < 0 or temp_b >= self.b:
                continue
            else:
                cock_map[pin_a][pin_b] = 0
                pin_a = temp_a
                pin_b = temp_b
                cock_map[pin_a][pin_b] = "*"
                stack_map[pin_a][pin_b] += 1
                cnt += 1

            check = True
            for i in range(self.a):
                for j in range(self.b):
                    if stack_map[i][j] == 0: check = False
            if check == True: cont = False
        print cnt
        print stack_map # 기존의 a,b를 모두 글로벌 변수 self.a, self.b로 변환

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

제 PC에서 100*100 기준시 빠를때는 4~5초 정도 소요되고, 느릴때에는 100초 정도가 걸렸습니다.
매번 소요시간이 일정치 않은걸로 봤을때, 파이썬 기본 랜덤 모듈의 난수생성 방식과 다른
방법을 사용해야 할것같은데 아직 대안은 찾지 못했습니다. 파이썬의 기본 난수 생성 알고리즘이
Mersenne Twister 인걸로 알고있는데 다른 방식의 난수생성 알고리즘을 적용하면
좀더 빨라질지 모르겠습니다.

coding by python beginner

import random
import time

startTime = time.time()

w = 100; h = 100; pos = [0, 0]; moveCnt = 0
posCounter = [[0 for x in range(w)] for y in range(h)]
posCounter[pos[0]][pos[1]] += 1

def getMovablePos():
    movablePos = [
        [[-1, -1], [-1, 0], [-1, 1]],
        [[0, -1], False, [0, 1]],
        [[1, -1], [1, 0], [1, 1]]
    ]

    if pos[0] == 0:
        movablePos[0] = list([False])*3
    elif pos[0] == h-1:         
        movablePos[2] = list([False])*3

    if pos[1] == 0:
        for p in movablePos: p[0] = False
    elif pos[1] == w-1:
        for p in movablePos: p[2] = False

    rs = []
    for line in movablePos:
        for p in line:
            if p is not False: rs.append(p) 
    return rs


def randomWalk():
    movablePos = getMovablePos()
    movePos = movablePos[random.randrange(0, len(movablePos))]

    for i in range(2): pos[i] += movePos[i]
    posCounter[pos[0]][pos[1]] += 1 


def chkEnd():
    for i in range(len(posCounter)):
        for j in range(len(posCounter[0])):
            if posCounter[i][j] == 0: return False          
    return True

while True:
    if chkEnd(): break      
    randomWalk()
    moveCnt += 1

endTime = time.time()
print(posCounter, moveCnt, endTime - startTime)
※ 상대에게 상처를 주기보다 서로에게 도움이 될 수 있는 댓글을 달아 주세요.
% MATLAB
function [map, cnt] = solution(r, c, ini)

    % map : 각지점에서 바퀴벌레가 멈추었던 횟수
    % cnt : 총 움직인 횟수 (초기 자리는 제외)

    map = zeros(r,c);
    indexmap = reshape(1:r*c, size(map));
    map(ini) = 1;
    cnt = 0;
    H = ones(3,3); % conv kernel
    currPos = ini;

    while inf
        cnt = cnt+1; % 움직임을 카운팅

        % 한위치에서 움직일수있는 가능성 공간(가로 세로 대각)
        t = false(r,c);
        t(currPos) = true;
        possible = logical(conv2(double(t), H, 'same'));
        possible(currPos) = false;  % 제자리에 있는것은 불가능하다고 가정
        ind = indexmap(possible);
        % 랜덤으로 이동
        currPos = ind(randi([1,length(ind)],1));
        map(currPos) = map(currPos)+1; % 각위치에 몇번 지나간지에 대한 카운팅

        % 모든 칸을 지나가면 while문 종료
        if all(map(:) ~= 0)
            break;
        end
    end
end

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

풀이 작성

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

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


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