์ฐธ๊ณ ) ์ด๊ฒ์ด ์ทจ์
์ ์ํ ์ฝ๋ฉํ
์คํธ๋ค with ํ์ด์ฌ ์ฑ
์ ๊ธฐ๋ฐ์ผ๋ก ์์ฑ๋ ๋ฌธ์ ์ ์ฝ๋์
๋๋ค.
๋ฐ๋ผ์ ๋ฌธ์ ๋ ์์ธํ๊ฒ ์ ์ง ์๊ณ , ๊ฐ๋จํ ์ค๋ช
๊ณผ ์ ์ฝ๋๋ง ์ฌ๋ฆฌ๊ฒ ์ต๋๋ค.
http://www.yes24.com/Product/Goods/91433923
์์ 4-1) ์ํ์ข์ฐ
- ์๋ฎฌ๋ ์ด์ ๋ฌธ์ ์ ๋ํ์ ์ธ ํํ
- ๋์ฒด๋ก ์ฝํ ์ 1~2๋ฒ ๋ฌธ์ ๋ ๊ทธ๋ฆฌ๋๋ ์ด๋ฐ ๊ตฌํ ๋ฌธ์ ๋ผ๊ณ ํ๋ค.
N x N ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๊ณต๊ฐ์ด ์๋ค.
์ด๋ ๊ณํ์ ์
๋ ฅ๋ฐ๋๋ค. ( L / R / U / D )
- L : ์ผ์ชฝ์ผ๋ก ํ ์นธ ์ด๋
- R : ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ ์ด๋
- U : ์๋ก ํ ์นธ ์ด๋
- D : ์๋๋ก ํ ์นธ ์ด๋
์ฒ์์ (1,1) ์๋ฆฌ์์ ์์ํ๊ณ , ์ด๋ ๊ณํ์ ๋ฐ๋ผ ์ด๋ํ ํ์ ์์น๋ฅผ ๊ตฌํ๋ ๋ฌธ์
๋จ, ์ขํ๋ฅผ ๋ฒ์ด๋๊ฒ ๋๋ ์ด๋๊ณํ์ ๋ฌด์๋๋ค.
์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์์๋ ๋ค์๊ณผ ๊ฐ๋ค.
์
๋ ฅ์์
5
R R R U D D
์ถ๋ ฅ์์
3 4
<๋ฌธ์ ํ์ด>
๋๋ ์ฐ์ ์ฒซ ์์น (1,1)์ place๋ก ์ง์ ํ๋ค.
๊ทธ๋ฆฌ๊ณ ํจ์ ์์ LRUD๋ผ๋ ์ด๋ ๊ณํ์ ๋ด์ ํจ์๋ฅผ ๋ฐ๋ก ๋ง๋ค์ด์ ์งํํ๋ค.
<๋ด๊ฐ ํผ ๋ฌธ์ >
def solution(N, route):
place = [1,1]
def LRUD(a, place):
temp_place = list(place)
if a == 'R':
temp_place[1] += 1
elif a == 'L':
temp_place[1] -= 1
elif a == 'U':
temp_place[0] -= 1
elif a == 'D':
temp_place[0] += 1
if (temp_place[0] < 1) or (temp_place[1] < 1) or (temp_place[1] > N) or (temp_place[0] > N) :
return place #์์น๊ฐ ๋ฒ์ด๋๋ฉด ๊ฐ์ง์๊ณ ๋ค์ place๋ก ๋ฐํ
else: # ๋ฒ์ด๋์ง ์๋๋ค๋ฉด
place = list(temp_place) # ๋ณํ๊ฑธ๋ก ์
๋ฐ์ดํธ ์ณ์ฃผ๊ณ
return place
for i in range(0, len(route)):
a = route.pop(0)
place = LRUD(a, place)
return place
์ฌ๊ธฐ์ ์กฐ๊ธ ์๊ฐ์ด ๊ฑธ๋ ธ๋๊ฒ, list๋ฅผ ๋ณต์ฌํ๋ ๊ณผ์ ์์ ์๊พธ ํด๊ฒฐํ์ง ๋ชปํด์ ์ธํฐ๋ท ๊ฒ์์ ํ๋ค. ใ
ใ
....
๋ฆฌ์คํธ๋ฅผ ๋ณต์ฌํ ๋๋ ์๋์ ๊ฐ์ ์ฌํญ์ ์ฃผ์ํด์ ๋ณต์ฌํด์ผ ํจ์ ์์๋ค!!
์ญ์ ๋ ๊ดด๋กญํ๋๊ฑด ๊ธฐ๋ณธ ๋ฌธ๋ฒ์ด์ผ... ์ญ์,,, ์ธ์ ๋ ๊ธฐ์ด๊ฐ ์ ์ผ ์ค์ํดใ ใ
temp_list = list
# ์ด๋ ๊ฒ ํ๋ฉด, ๋ฆฌ์คํธ ์์ฒด์ ๋์ผํ ๊ฐ์ฒด์ ์ด๋ฆ์ด ๋๊ฐ ์๊ธด๋ค๊ณ ์ดํดํ๋ฉด ๋๋ค.
# ๋ฐ๋ผ์ list๊ฐ ๋ณํด๋ ๋์์ temp_list๊ฐ ๋ณํ๋ค.
#๊ทธ๋์ ๋ฆฌ์คํธ๋ฅผ ๋ณต์ฌํ๊ณ ์ถ๋ค๋ฉด,
# ์๋ ์ฒ๋ผ ๋ค์ list ๊ฐ์ฒด๋ฅผ ์๋กญ๊ฒ ๋ถ๋ฌ์์ผํ๋ค.
temp_list = list(list)
๋ต์ ์ถ๋ ฅ)
N = 5
route = ['R','R','R','U','D','D']
solution(N, route)
<์ฑ ์ ์๋ ์ ๋ต๊ณผ ๋น๊ต>
n = 5
x, y = 1, 1
plans = ['R','R','R','U','D','D']
# LRUD ์ ๋ํ ์ด๋ ๋ฐฉํฅ์ 4์ฐจ์์ผ๋ก ํํ
# ์ธ๋ฑ์ค 0์ด L, 1์ด R, 2๊ฐ U ...
dx = [0, 0, -1, 1]
dy = [-1, 1, 0, 0]
move_types = ['L', 'R', 'U', 'D']
#์ด๋๊ณํ์ ํ๋์ฉ ํ์ธ
for plan in plans:
# ์ด๋ ํ ์ขํ ๊ตฌํ๊ธฐ
for i in range(len(move_types)):
if plan == move_types[i]:
nx = x + dx[i]
ny = y + dy[i]
# ์ด๋์ ์ ๊ณต๊ฐ์ ๋ฒ์ด๋๋์ง ํ์ธ
if nx < 1 or ny < 1 or nx > n or ny > n :
continue # ๋์ด์ ํด๋น ์์ for ๋ฌธ์์ ๋์ง ์๊ณ ๋๊ฐ
x, y = nx, ny
print(x,y)
์ฑ
์ ์ด๋ ๊ฒ ๋ฌธ์ ๋ฅผ ํ์ด๋จ๋ค. ๋ด๊ฐ ์๊ฐํ์ง ๋ชปํ๋ ๋ฐฉ๋ฒ์ผ๋ก
L R U D๋ฅผ ํ๋ํ๋ ์
๋ ฅ๋ฐ์ง ์๊ณ , dx, dy, move_types ์ ์ธ๋ฑ์ค๋ก ์ค์ ํ ์ ์๋ค๋ ๊ฒ(?)์ ๋ฐฐ์ ๋ค.
์๋ฌด๋๋ ์ฑ ์ ๋์จ ์ฝ๋๊ฐ ์ข๋ ๊ฐ๊ฒฐํ๊ณ ์งง๊ธฐ๋๋ฌธ์ ๊ตฌํํ๋๋ฐ ์๊ฐ์ด ๋ ๊ฑธ๋ฆด ๊ฒ ๊ฐ๋ค.