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[i]๋ ๋ค์ ๋ฌธ์๋ค๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ ์์์ง์ ์ ํ๋๋ง ์ฃผ์ด์ง๋๋ค.
- park๋ ์ง์ฌ๊ฐํ ๋ชจ์์ ๋๋ค.
- 3 ≤ park[i]์ ๊ธธ์ด ≤ 50
- 1 ≤ routes์ ๊ธธ์ด ≤ 50
- routes์ ๊ฐ ์์๋ ๋ก๋ด ๊ฐ์์ง๊ฐ ์ํํ ๋ช ๋ น์ด๋ฅผ ๋ํ๋ ๋๋ค.
- ๋ก๋ด ๊ฐ์์ง๋ routes์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ์์๋๋ก ๋ช ๋ น์ ์ํํฉ๋๋ค.
- routes์ ์์๋ "op n"๊ณผ ๊ฐ์ ๊ตฌ์กฐ๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, op๋ ์ด๋ํ ๋ฐฉํฅ, n์ ์ด๋ํ ์นธ์ ์๋ฅผ ์๋ฏธํฉ๋๋ค.
- op๋ ๋ค์ ๋ค ๊ฐ์ง์ค ํ๋๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- N : ๋ถ์ชฝ์ผ๋ก ์ฃผ์ด์ง ์นธ๋งํผ ์ด๋ํฉ๋๋ค.
- S : ๋จ์ชฝ์ผ๋ก ์ฃผ์ด์ง ์นธ๋งํผ ์ด๋ํฉ๋๋ค.
- W : ์์ชฝ์ผ๋ก ์ฃผ์ด์ง ์นธ๋งํผ ์ด๋ํฉ๋๋ค.
- E : ๋์ชฝ์ผ๋ก ์ฃผ์ด์ง ์นธ๋งํผ ์ด๋ํฉ๋๋ค.
- 1 ≤ n ≤ 9
- op๋ ๋ค์ ๋ค ๊ฐ์ง์ค ํ๋๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
park | routes | result |
["SOO","OOO","OOO"] | ["E 2","S 2","W 1"] | [2,1] |
["SOO","OXX","OOO"] | ["E 2","S 2","W 1"] | [0,1] |
["OSO","OOO","OXO","OOO"] | ["E 2","S 3","W 1"] | [0,0] |
์์ค ์ฝ๋
# 1
def solution(park, routes):
# x = ์ด ๋ฒํธ / y = ํ ๋ฒํธ
# ํ์ด์ ์ต๋๊ฐ ์ค์
x_max = len(park[0])
y_max = len(park)
# ์์ ์์น ์ฐพ๊ธฐ
x = 0
y = 0
for i in range(y_max): # i = ํ ๋ฒํธ = y๊ฐ
for j in range(x_max): # j = ์ด ๋ฒํธ = x๊ฐ
if park[i][j] == 'S':
x = j
y = i
break
# ์ขํ ์ด๋
for route in routes:
# ๋ฐฉํฅ๊ณผ ์ด๋๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅ
direction, distance = route.split(" ")
# ํ์ฌ์ ์ขํ๋ฅผ ์์๋ก ์ด๋
xx = x
yy = y
# ํ ์นธ์ฉ ์ด๋ํ๋ฉด์ ๊ณต์์ ๋ฒ์ด๋๊ฑฐ๋ ์ฅ์ ๋ฌผ์ ๋ง๋๋์ง ํ์ธ
# step์ด ์ด๋๊ฑฐ๋ฆฌ์ ๊ฐ์์ง๋ฉด ํ์ฌ ์ขํ๋ฅผ ์์ ์ขํ๋ก ๋ณ๊ฒฝ
for step in range(1, int(distance)+1):
# ๋์ชฝ์ผ๋ก ์ด๋
if direction == 'E' and xx != x_max-1 and park[yy][xx+1] != 'X':
xx += 1
if step == int(distance):
x = xx
# ์์ชฝ์ผ๋ก ์ด๋
elif direction == 'W' and xx != 0 and park[yy][xx-1] != 'X':
xx -= 1
if step == int(distance):
x = xx
# ๋จ์ชฝ์ผ๋ก ์ด๋
elif direction == 'S' and yy != y_max-1 and park[yy+1][xx] != 'X':
yy += 1
if step == int(distance):
y = yy
# ๋ถ์ชฝ์ผ๋ก ์ด๋
elif direction == 'N' and yy != 0 and park[yy-1][xx] != 'X':
yy -= 1
if step == int(distance):
y = yy
return [y, x]
ํ์ด # 1
- ์ขํ์์ ๊ณ ๋ ค์ฌํญ
- x = ์ด ๋ฒํธ / y = ํ ๋ฒํธ
- x_max = ์ด์ ๊ธธ์ด / y_max = ํ์ ๊ธธ์ด
- ์์ ์์น ์ฐพ๊ธฐ
- i = ํ ๋ฒํธ = y๊ฐ / j = ์ด ๋ฒํธ / x๊ฐ
- ์์ ๋ด์ฉ์ ๊ณ ๋ คํ์ฌ ์์์ S ์ฐพ๊ธฐ
- ์ขํ ์ด๋
- ๋์ด์ฐ๊ธฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ์์ ๊ฐ์ ๋ฐฉํฅ(direction), ๋ค์ ๊ฐ์ ์ด๋๊ฑฐ๋ฆฌ(distance)
- ํ์ฌ ์ขํ์ ๋์ผํ ์์ ์ขํ๋ฅผ ๋ง๋ค์ด์ ์ด๋ (์กฐ๊ฑด์ ๋ง์กฑ์ํค์ง ์์ ๊ฒฝ์ฐ ์ด๊ธฐํํ๊ธฐ ์ํด ํ์)
- ๋ฐฉํฅ ํ์ธ
- E = ๋์ชฝ : x์ขํ + 1
- W = ์์ชฝ : x์ขํ - 1
- S = ๋จ์ชฝ : y์ขํ + 1
- N = ๋ถ์ชฝ : y์ขํ -1
- ํ์ฌ ์ขํ๊ฐ ํ์ด๋ ์ด์ ๊ธธ์ด๋ฅผ ๋ฒ์ด๋๋์ง ํ์ธ
- ํ ์นธ ์ด๋ํ์ ๋ ์ฅ์ ๋ฌผ์ด ์๋์ง ํ์ธ
- ๋ฐฉํฅ ํ์ธ
- ๊ฐ ์กฐ๊ฑด์ ๋ชจ๋ ๋ง์กฑํ ๊ฒฝ์ฐ ์์ ์ขํ๋ฅผ ํ ์นธ ์ด๋
- step์ด ์ด๋ ๊ฑฐ๋ฆฌ์ ๋๋ฌํ๋ฉด ํ์ฌ ์ขํ๋ฅผ ์์ ์ขํ๋ก ๋ฐ๊พธ๊ธฐ
- x๋ ์ด ๋ฒํธ, y๋ ํ ๋ฒํธ์ด๋ฏ๋ก [y,x] ๋ฅผ ๋ฐํ
# 2
def solution(park, routes):
# ํ์ด์ ์ต๋๊ฐ ์ค์
w, h = len(park[0]), len(park)
# ๋ฐฉํฅ๋ณ๋ก ์ด๋ํด์ผํ๋ ๊ฑฐ๋ฆฌ๋ฅผ ๋์
๋๋ฆฌ์ ์ ์ฅ
move = {"N":(-1,0), "S":(1,0), "W":(0,-1), "E":(0,1)}
# ์์ ์์น ์ฐพ๊ธฐ
x, y = 0, 0
for i in range(h):
for j in range(w):
if park[i][j] == "S":
x, y = i, j
break
# ์ขํ ์ด๋
for route in routes:
# ๋ฐฉํฅ๊ณผ ์ด๋๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅ
direction, distance = route.split(" ")
# ํ์ฌ์ ์ขํ๋ฅผ ์ ์ฅํด์ ์กฐ๊ฑด์ ๋ง์กฑํ์ง ๋ชปํ๋ฉด ํด๋น๊ฐ์ผ๋ก ์ด๊ธฐํ
dx, dy = x, y
for idx in range(int(distance)):
# ์ด๋ํ ์์น
nx = x + move[direction][0]
ny = y + move[direction][1]
if 0 <= nx <= h-1 and 0 <= ny <= w-1 and (park[nx][ny]!="X"):
x, y = nx, ny
else:
x, y = dx, dy
break
return [x,y]
ํ์ด #2
- ์์ ํ์ด์ ๋ฐ๋๋ก x๋ฅผ ํ ๋ฒํธ, y๋ฅผ ํ ๋ฒํธ๋ก ์๊ฐํ ํ์ด
- ํค๊ฐ ์ด๋ ๋ฐฉํฅ, ๊ฐ์ด ์ด๋ํด์ผํ๋ ๊ฑฐ๋ฆฌ์ธ ๋์
๋๋ฆฌ ์์ฑ
- E = ๋์ชฝ : y์ขํ + 1
- W = ์์ชฝ : y์ขํ - 1
- S = ๋จ์ชฝ : x์ขํ + 1
- N = ๋ถ์ชฝ : x์ขํ -1
- ์์ ์์น ์ฐพ๊ธฐ
- ํ์ฌ ์ขํ๋ฅผ dx, dy์ ์ ์ฅ (์กฐ๊ฑด์ ๋ง์กฑ์ํค์ง ์์ ๊ฒฝ์ฐ ์ด๊ธฐํํ๊ธฐ ์ํด ํ์)
- ์์ ์ขํ nx, ny๋ฅผ ๋ง๋ค์ด ๋ชจ๋ ์กฐ๊ฑด์ ๋ง์กฑํ์ ๊ฒฝ์ฐ์ ํ์ฌ ์ขํ๋ฅผ ๋ณ๊ฒฝ
x์ขํ, y์ขํ ๋์ค๋ฉด ์ผ๋จ ํท๊ฐ๋ฆฌ๊ธฐ ์์....๋ค์ ์ฐจ๊ทผ์ฐจ๊ทผ ์๊ฐํด๋ณด๊ฒ ๋ค๋ฉฐ ์ฝ๋ 12938091๋ฒ ์์ ํ๋๋ฐ ๊ฐ์ธ์ ์ผ๋ก ์ฒซ ๋ฒ์งธ ํ์ด๊ฐ ์ข ๋ ์ดํดํ๊ธฐ ์ฌ์ ๋ค. ๋ ๋ฒ์งธ ํ์ด๋ ์๋๊ฐ ์กฐ๊ธ ๋ ๋น ๋ฅด์ง๋ง ๋จธ๋ฆฌ๊ฐ ๋ฐ๋ผ์ฃผ์ง ์์์ ํ๋ค์๋ค...ํด...์ด์จ๋ ํ์์ผ๋๊น ์ฌ์ด์ผ๊ฒ ๋ค.๊ณต์ ์ฐ์ฑ ์ ์์ด๋ ๊ฒ ๋นก์ธ๊ฒ ํ์๋ ๊ฑฐ์์... ๐๐ป ๐๐ป