💫공원 산책

https://school.programmers.co.kr/learn/courses/30/lessons/172928

프로그래머스

[문제 설명]

지나다니는 길을 'O', 장애물을 'X'로 나타낸 직사각형 격자 모양의 공원에서 로봇 강아지가 산책을 하려합니다. 산책은 로봇 강아지에 미리 입력된 명령에 따라 진행하며, 명령은 다음과 같은 형식으로 주어집니다.

• ["방향 거리", "방향 거리" … ]

예를 들어 "E 5"는 로봇 강아지가 현재 위치에서 동쪽으로 5칸 이동했다는 의미입니다. 로봇 강아지는 명령을 수행하기 전에 다음 두 가지를 먼저 확인합니다.

• 주어진 방향으로 이동할 때 공원을 벗어나는지 확인합니다.
• 주어진 방향으로 이동 중 장애물을 만나는지 확인합니다.

위 두 가지중 어느 하나라도 해당된다면, 로봇 강아지는 해당 명령을 무시하고 다음 명령을 수행합니다.
공원의 가로 길이가 W, 세로 길이가 H라고 할 때, 공원의 좌측 상단의 좌표는 (0, 0), 우측 하단의 좌표는 (H - 1, W - 1) 입니다.

공원을 나타내는 문자열 배열 park, 로봇 강아지가 수행할 명령이 담긴 문자열 배열 routes가 매개변수로 주어질 때, 로봇 강아지가 모든 명령을 수행 후 놓인 위치를 [세로 방향 좌표, 가로 방향 좌표] 순으로 배열에 담아 return 하도록 solution 함수를 완성해주세요.

 

제한사항

• 3 ≤ park의 길이 ≤ 50
  • 3 ≤ park[i]의 길이 ≤ 50
    • park[i]는 다음 문자들로 이루어져 있으며 시작지점은 하나만 주어집니다.
      • S : 시작 지점
      • O : 이동 가능한 통로
      • X : 장애물
  • park는 직사각형 모양입니다.
• 1 ≤ routes의 길이 ≤ 50
  • routes의 각 원소는 로봇 강아지가 수행할 명령어를 나타냅니다.
  • 로봇 강아지는 routes의 첫 번째 원소부터 순서대로 명령을 수행합니다.
  • routes의 원소는 "op n"과 같은 구조로 이루어져 있으며, op는 이동할 방향, n은 이동할 칸의 수를 의미합니다.
    • op는 다음 네 가지중 하나로 이루어져 있습니다.
      • N : 북쪽으로 주어진 칸만큼 이동합니다.
      • S : 남쪽으로 주어진 칸만큼 이동합니다.
      • W : 서쪽으로 주어진 칸만큼 이동합니다.
      • E : 동쪽으로 주어진 칸만큼 이동합니다.
    • 1 ≤ n ≤ 9

[나의 풀이]

def solution(park, routes):
    # 시작 위치 찾기
    for i, row in enumerate(park):
        if "S" in row:
            position = [i, row.index("S")]
            break
    
    # 방향 딕셔너리 정의
    directions = {
        "N": (-1, 0),
        "S": (1, 0),
        "W": (0, -1),
        "E": (0, 1)
    }
    
    for route in routes:
        op, n = route.split()  # 방향과 거리 분리
        n = int(n)  # 거리 정수 변환

        # 이동 중 장애물 또는 공원 경계 확인
        valid = True
        for step in range(1, n + 1):
            check_row = position[0] + directions[op][0] * step
            check_col = position[1] + directions[op][1] * step

            # 공원을 벗어나거나 장애물을 만나면 이동 중단
            if not (0 <= check_row < len(park) and 0 <= check_col < len(park[0])):
                valid = False
                break
            if park[check_row][check_col] == "X":
                valid = False
                break

        # 이동이 가능하면 위치 업데이트
        if valid:
            position = [
                position[0] + directions[op][0] * n,
                position[1] + directions[op][1] * n,
            ]
    
    return position

 

[다른 풀이]

1)

class Dog:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.g = {"N": (-1, 0), "W": (0, -1), "E": (0, 1), "S": (1, 0)}

    def move(self, park, direction, distance):
        i, j = self.g[direction]
        x, y = self.x + (i * distance), self.y + (j * distance)
        if x < 0 or y < 0 or x >= len(park) or y >= len(park[0]):
            return park
        elif "X" in park[x][min(self.y, y) : max(self.y, y) + 1] or "X" in [
            row[y] for row in park[min(self.x, x) : max(self.x, x)]
        ]:
            return park
        park[self.x][self.y] = "O"
        park[x][y] = "S"
        self.x = x
        self.y = y
        return park

    @classmethod
    def detect_start_dogs_location(cls, park):
        for i, row in enumerate(park):
            for j, item in enumerate(row):
                if item == "S":
                    return i, j


def solution(park, routes):
    park = [list(row) for row in park]
    x, y = Dog.detect_start_dogs_location(park)

    dog = Dog(x, y)

    for route in routes:
        direction, distance = route.split()
        park = dog.move(park, direction, int(distance))

    return [dog.x, dog.y]

 

(1) Dog 클래스

 

__init__ 메서드 (생성자)

def __init__(self, x, y):
    self.x = x  # 강아지의 현재 x좌표 (행)
    self.y = y  # 강아지의 현재 y좌표 (열)
    self.g = {"N": (-1, 0), "W": (0, -1), "E": (0, 1), "S": (1, 0)}  # 방향에 따른 이동 벡터

move 메서드

def move(self, park, direction, distance):
    i, j = self.g[direction]  # 방향에 따른 이동 벡터
    x, y = self.x + (i * distance), self.y + (j * distance)  # 최종 목표 좌표 계산

    # 1. 공원 밖으로 나가는 경우
    if x < 0 or y < 0 or x >= len(park) or y >= len(park[0]):
        return park  # 이동하지 않고 공원 상태 그대로 반환

    # 2. 이동 경로에 장애물이 있는 경우
    elif "X" in park[x][min(self.y, y) : max(self.y, y) + 1] or "X" in [
        row[y] for row in park[min(self.x, x) : max(self.x, x)]
    ]:
        return park  # 이동하지 않고 공원 상태 그대로 반환

    # 3. 이동 가능한 경우
    park[self.x][self.y] = "O"  # 이전 위치를 통로("O")로 변경
    park[x][y] = "S"  # 목표 위치를 강아지("S")로 표시
    self.x = x  # 강아지의 x좌표 업데이트
    self.y = y  # 강아지의 y좌표 업데이트
    return park  # 업데이트된 공원 상태 반환

detect_start_dogs_location 클래스 메서드

@classmethod
def detect_start_dogs_location(cls, park):
    for i, row in enumerate(park):  # 행과 열을 탐색
        for j, item in enumerate(row):
            if item == "S":  # 시작 위치("S") 발견
                return i, j  # 시작 위치 좌표 반환

 

(2) solution 함수

 

 

2)

dx = {'N':-1, 'S':1, 'E':0, 'W': 0}
dy = {'N': 0, 'S':0, 'E':1, 'W':-1}

def solution(park, routes):
    answer = []
    x, y = -1, -1
    N, M = len(park), len(park[0])
    for i in range(N):
        for j in range(M):
            if park[i][j] == 'S':
                x, y = i, j

    for route in routes:
        dir_, dist = route.split(' ')

        isFalse = False
        for i in range(1, int(dist) + 1):
            nx, ny = x + dx[dir_] * i, y + dy[dir_] * i
            if nx < 0 or ny < 0 or nx > N-1 or ny > M-1:
                isFalse = True
                break
            if park[nx][ny] == 'X':
                isFalse = True
                break

        if isFalse:
            continue
        nx, ny = x + dx[dir_] * int(dist), y + dy[dir_] * int(dist)
        x, y = nx, ny

    answer = [x, y]

    return answer

혹은

dx = {'N':-1, 'S':1, 'E':0, 'W': 0}
dy = {'N': 0, 'S':0, 'E':1, 'W':-1}

def solution(park, routes):
    answer = []
    x, y = -1, -1
    N, M = len(park), len(park[0])
    for i in range(N):
        for j in range(M):
            if park[i][j] == 'S':
                x, y = i, j

    for route in routes:
        dir_, dist = route.split(' ')

        isTrue = True
        for i in range(1, int(dist) + 1):
            nx, ny = x + dx[dir_] * i, y + dy[dir_] * i
            if nx < 0 or ny < 0 or nx > N-1 or ny > M-1:
                isTrue = False
                break
            if park[nx][ny] == 'X':
                isTrue = False
                break

        if isTrue:
            nx, ny = x + dx[dir_] * int(dist), y + dy[dir_] * int(dist)
            x, y = nx, ny

    answer = [x, y]

    return answer

 

3)

def solution(park, routes):
    W = len(park[0])
    park = [['X']*(W+2)] + [[*'X'+i+'X'] for i in park] + [['X']*(W+2)]

    x,y = 1,0
    while park[x][y]!='S':
        y += 1
        if y>W:
            x,y = x+1,0

    delta = {k:v for k,v in zip('NEWS',[(-1,0),(0,1),(0,-1),(1,0)])}
    for i in routes:
        v,d = i.split()
        for k in range(1,int(d)+1):
            X,Y = x+k*delta[v][0], y+k*delta[v][1]
            if park[X][Y]=='X':
                break
        else:
            x,y = X,Y
    return [x-1,y-1]

(1) park 확장

W = len(park[0])
park = [['X']*(W+2)] + [[*'X'+i+'X'] for i in park] + [['X']*(W+2)]

⭐[*'X'+i+'X']에서 *의 역할은?

*은 Python의 언패킹 연산자입니다.

이 연산자는 **문자열 또는 이터러블(iterable)**을 개별 요소로 분리해서 처리할 때 사용됩니다

(2) 강아지 시작위치 찾기

x, y = 1, 0
while park[x][y] != 'S':
    y += 1
    if y > W:
        x, y = x + 1, 0

(3) 이동명령 처리

delta = {k:v for k,v in zip('NEWS', [(-1,0), (0,1), (0,-1), (1,0)])}
for i in routes:
    v, d = i.split()
    for k in range(1, int(d) + 1):
        X, Y = x + k * delta[v][0], y + k * delta[v][1]
        if park[X][Y] == 'X':
            break
    else:
        x, y = X, Y

(4) 최종좌표 반환

return [x - 1, y - 1]

강아지의 좌표(x, y)는 확장된 공원의 좌표를 기준으로 계산되므로, 원래 공원의 좌표로 변환하기 위해 -1을 합니다.

 

4)

def solution(park, routes):
    result = []
    for i in range(len(park)):
        for j in range(len(park[0])):
            if park[i][j] == 'S':
                cur_x, cur_y = j, i
                continue

    def check(x, y):
        if (0 > x or x >= len(park[0])) or (0 > y or y >= len(park)) or park[y][x] == 'X':
            return False
        return True

    for route in routes:
        direct, move = route.split(' ')
        move = int(move)
        if direct == 'E':
            n_x = cur_x + move
            for t_x in range(cur_x, n_x + 1):
                if check(t_x, cur_y) == False:
                    break
            else:
                cur_x = n_x
        elif direct == 'W':
            n_x = cur_x - move
            for t_x in range(n_x, cur_x + 1):
                if check(t_x, cur_y) == False:
                    break
            else:
                cur_x = n_x
        elif direct == 'N':
            n_y = cur_y - move
            for t_y in range(n_y, cur_y + 1):
                if check(cur_x, t_y) == False:
                    break
            else:
                cur_y = n_y
        elif direct == 'S':
            n_y = cur_y + move
            for t_y in range(cur_y, n_y + 1):
                if check(cur_x, t_y) == False:
                    break
            else:
                cur_y = n_y

    return [cur_y, cur_x]

 

5)

def solution(park, routes):

    # 공원의 높이와 너비 계산
    H = len(park)
    W = len(park[0])

    # 시작점 "S"의 인덱스 추출
    for i, element in enumerate(park):
        arr = list(element)
        if "S" in arr:
            start = [i, list(arr).index("S")]

    pos = start

    for route in routes:

        # 명령어 입력 처리
        op, n = route.split(' ')
        n = int(n)

        obstacle = 0  #장애물을 마주칠시 1로 바뀌는 변수(스위치)


        # 북쪽으로 이동하는 경우
        if op == 'N':
            if pos[0] - n < 0:
                print("Out of range: N")
                continue
            else:
                for i in range(1, n+1):
                    if "X" == park[pos[0] - i][pos[1]]:
                        obstacle = 1
                        print("Obstacle encountered: N")
                        continue

            if obstacle == 1:
                continue
            else:
                pos[0] -= n
                print("Operation Complete: N")

        # 남쪽으로 이동하는 경우
        elif op == 'S':
            if pos[0] + n > H-1:
                print("Out of range: S")
                continue
            else:
                for i in range(1, n+1):
                    if "X" == park[pos[0] + i][pos[1]]:
                        obstacle = 1
                        print("Obstacle encountered: S")
                        continue

            if obstacle == 1:
                continue
            else:                
                pos[0] += n
                print("Operation Complete: S")

        # 서쪽으로 이동하는 경우
        elif op == 'W':
            if pos[1] - n < 0:
                print("Out of range: W")
                continue
            else:
                for i in range(1, n+1):
                    if "X" == park[pos[0]][pos[1] - i]:
                        obstacle = 1
                        print("Obstacle encountered: W")
                        continue

            if obstacle == 1:
                continue
            else:
                pos[1] -= n
                print("Operation Complete: W")

        # 동쪽으로 이동하는 경우
        elif op == 'E':
            if pos[1] + n > W-1:
                print("Out of range: E")
                continue
            else:
                for i in range(1, n+1):
                    if "X" == park[pos[0]][pos[1] + i]:
                        obstacle = 1
                        print("Obstacle encountered: E")
                        continue
            if obstacle == 1:
                continue
            else:
                pos[1] += n
                print("Operation Complete: W")


    answer = [pos[0], pos[1]]
    return answer