[ํ๋ก๊ทธ๋๋จธ์ค] ๐ ์ ํ๋ฒ์ค - [1์ฐจ] 2018 ์นด์นด์ค ๋ธ๋ผ์ธ๋ ์ฑ์ฉ / Python / KAKAO BLIND RECRUITMENT
๐ ์ ํ๋ฒ์ค - [1์ฐจ] 2018 ์นด์นด์ค ๋ธ๋ผ์ธ๋ ์ฑ์ฉ / Python / KAKAO BLIND RECRUITMENT
๋ฌธ์ ์ค๋ช
์นด์นด์ค์์๋ ๋ฌด๋ฃ ์ ํ๋ฒ์ค๋ฅผ ์ดํํ๊ธฐ ๋๋ฌธ์ ํ๊ต์ญ์์ ํธํ๊ฒ ์ฌ๋ฌด์ค๋ก ์ฌ ์ ์๋ค. ์นด์นด์ค์ ์ง์์ ์๋ก๋ฅผ 'ํฌ๋ฃจ'๋ผ๊ณ ๋ถ๋ฅด๋๋ฐ, ์์นจ๋ง๋ค ๋ง์ ํฌ๋ฃจ๋ค์ด ์ด ์ ํ์ ์ด์ฉํ์ฌ ์ถ๊ทผํ๋ค.
์ด ๋ฌธ์ ์์๋ ํธ์๋ฅผ ์ํด ์ ํ์ ๋ค์๊ณผ ๊ฐ์ ๊ท์น์ผ๋ก ์ดํํ๋ค๊ณ ๊ฐ์ ํ์.
- ์ ํ์ 09:00๋ถํฐ ์ด nํ t๋ถ ๊ฐ๊ฒฉ์ผ๋ก ์ญ์ ๋์ฐฉํ๋ฉฐ, ํ๋์ ์ ํ์๋ ์ต๋ m๋ช ์ ์น๊ฐ์ด ํ ์ ์๋ค.
- ์ ํ์ ๋์ฐฉํ์ ๋ ๋์ฐฉํ ์๊ฐ์ ๋๊ธฐ์ด์ ์ ํฌ๋ฃจ๊น์ง ํฌํจํด์ ๋๊ธฐ ์์๋๋ก ํ์ฐ๊ณ ๋ฐ๋ก ์ถ๋ฐํ๋ค. ์๋ฅผ ๋ค์ด 09:00์ ๋์ฐฉํ ์ ํ์ ์๋ฆฌ๊ฐ ์๋ค๋ฉด 09:00์ ์ค์ ์ ํฌ๋ฃจ๋ ํ ์ ์๋ค.
์ผ์ฐ ๋์์ ์ ํ์ ๊ธฐ๋ค๋ฆฌ๋ ๊ฒ์ด ๊ท์ฐฎ์๋ ์ฝ์, ์ผ์ฃผ์ผ๊ฐ์ ์ง์ํ ๊ด์ฐฐ ๋์ ์ด๋ค ํฌ๋ฃจ๊ฐ ๋ช ์์ ์ ํ ๋๊ธฐ์ด์ ๋์ฐฉํ๋์ง ์์๋๋ค. ์ฝ์ด ์ ํ์ ํ๊ณ ์ฌ๋ฌด์ค๋ก ๊ฐ ์ ์๋ ๋์ฐฉ ์๊ฐ ์ค ์ ์ผ ๋ฆ์ ์๊ฐ์ ๊ตฌํ์ฌ๋ผ.
๋จ, ์ฝ์ ๊ฒ์ผ๋ฅด๊ธฐ ๋๋ฌธ์ ๊ฐ์ ์๊ฐ์ ๋์ฐฉํ ํฌ๋ฃจ ์ค ๋๊ธฐ์ด์์ ์ ์ผ ๋ค์ ์ ๋ค. ๋ํ, ๋ชจ๋ ํฌ๋ฃจ๋ ์ ์ ์์ผ ํ๋ฏ๋ก 23:59์ ์ง์ ๋์๊ฐ๋ค. ๋ฐ๋ผ์ ์ด๋ค ํฌ๋ฃจ๋ ๋ค์๋ ์ ํ์ ํ๋ ์ผ์ ์๋ค.
์ ๋ ฅ ํ์
์ ํ ์ดํ ํ์ n, ์ ํ ์ดํ ๊ฐ๊ฒฉ t, ํ ์ ํ์ ํ ์ ์๋ ์ต๋ ํฌ๋ฃจ ์ m, ํฌ๋ฃจ๊ฐ ๋๊ธฐ์ด์ ๋์ฐฉํ๋ ์๊ฐ์ ๋ชจ์ ๋ฐฐ์ด timetable์ด ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค.
- 0 ๏ผ n โฆ 10
- 0 ๏ผ t โฆ 60
- 0 ๏ผ m โฆ 45
- timetable์ ์ต์ ๊ธธ์ด 1์ด๊ณ ์ต๋ ๊ธธ์ด 2000์ธ ๋ฐฐ์ด๋ก, ํ๋ฃจ ๋์ ํฌ๋ฃจ๊ฐ ๋๊ธฐ์ด์ ๋์ฐฉํ๋ ์๊ฐ์ด HH:MM ํ์์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
- ํฌ๋ฃจ์ ๋์ฐฉ ์๊ฐ HH:MM์ 00:01์์ 23:59 ์ฌ์ด์ด๋ค.
์ถ๋ ฅ ํ์
์ฝ์ด ๋ฌด์ฌํ ์ ํ์ ํ๊ณ ์ฌ๋ฌด์ค๋ก ๊ฐ ์ ์๋ ์ ์ผ ๋ฆ์ ๋์ฐฉ ์๊ฐ์ ์ถ๋ ฅํ๋ค. ๋์ฐฉ ์๊ฐ์ HH:MM ํ์์ด๋ฉฐ, 00:00์์ 23:59 ์ฌ์ด์ ๊ฐ์ด ๋ ์ ์๋ค.
๐ ํ์ด 1
def timeToMinute (time):
lst = time.split(':')
return int(lst[0])*60 + int(lst[1])
def minuteToTime (minute):
div, mod = divmod(minute,60)
return "%02d:%02d" % (div, mod)
def crewTime(timetable):
return [timeToMinute(time) for time in timetable]
def shuttleTime(n, t, start = '09:00'):
shuttle = [timeToMinute(start)]
for n1 in range(n-1):
shuttle.append(shuttle[-1]+t)
return shuttle
def duplicateTime(c,integrate):
if not c in integrate.keys():
return c
else:
return duplicateTime(c + 0.001, integrate)
def solution(n, t, m, timetable):
crew = sorted(crewTime(timetable))
shuttle = shuttleTime(n, t)
conTime = set(shuttle + crew)
for c in set(crew):
conTime.add(c - 1)
for con in sorted(list(conTime))[::-1]:
integrate = dict()
for c in crew:
integrate[duplicateTime(c,integrate)] = 'crew'
integrate[duplicateTime(con,integrate)] = 'con'
for sh in shuttle:
integrate[duplicateTime(sh,integrate)] = 'shuttle'
waiting_line = []
for time in sorted(integrate.keys()):
if 'crew' == integrate[time]:
waiting_line.append('crew')
elif 'con' == integrate[time]:
waiting_line.append('con')
elif 'shuttle' == integrate[time]:
waiting_line = waiting_line[m:]
if not 'con' in waiting_line:
return minuteToTime(con)
๋ฐฑํธ๋ํน(Backtracking) ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ ํ์ด์ด๋ค.
def timeToMinute (time):
lst = time.split(':')
return int(lst[0])*60 + int(lst[1])
def minuteToTime (minute):
div, mod = divmod(minute,60)
return "%02d:%02d" % (div, mod)
์๊ฐ์ ํํ ํ์์ ์ต์ํ์ ๋จ์๋ก ๊ณ์ฐ ํ๋ ๊ฒ ํธํ๊ธฐ ๋๋ฌธ์ ๋ ํ์์ ๋ณํํ๋ ํจ์๋ฅผ ๊ฐ๊ฐ ๋ง๋ค์๋ค.
def shuttleTime(n, t, start = '09:00'):
shuttle = [timeToMinute(start)]
for n1 in range(n-1):
shuttle.append(shuttle[-1]+t)
return shuttle
์
ํ์ด ์ค๋ ์๊ฐ์ ๋ํ ๋ฆฌ์คํธ๋ฅผ ๋ฐํํ๋ ํจ์๋ ํ๋ ๋ง๋ค์๋ค. ์ฌ๊ธฐ์ ์์ ๋ง๋ ํ์ ๋ณํ ํจ์์ธ timeToMinute
๋ฅผ ์ฌ์ฉํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ๋ฌธ์ ๋ก ๋ค์ด๊ฐ๊ฒ ๋๋ ๋ฐ ์
ํ ์๊ฐ๊ณผ ํฌ๋ฃจ๋ค์ ์๊ฐ์ ํฉ์น ์งํฉ์ ๋ง๋ค๊ณ , ์ถ๊ฐ์ ์ผ๋ก ๊ฐ๋ฅ ์ฑ์ด ์๋ ์๊ฐ์ผ๋ก ํด๋น ์๊ฐ์ 1๋ถ์ ๋บ ๊ฐ์ ์งํฉ์ ์ถ๊ฐํด์ ์ ๋ต์ ๊ฐ๋ฅ์ฑ์ ๊ฐ์ง ๊ฒ๋ค๋ง ๋ชจ์ธ ์ฝ์ ์๊ฐ์ด ๋ conTime
์ด๋ผ๋ ์งํฉ์ ์์ฑํ๋ค.
์ด ๋, conTime
์ ์๊ฐ์ด ํฐ ๊ฒ๋ถํฐ ๋ด๋ฆผ์ฐจ์์ผ๋ก ํ์ธํ๊ฒ ๋๋ฉด ์ฝ์ด ๋ฒ์ค๋ฅผ ๋ชป ํ๋ค๊ฐ ์ฒ์์ผ๋ก ๋ฒ์ค๋ฅผ ํ ์ ์๋ ์๊ฐ์ด ๊ตฌํด์ง ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ์ด ์๊ฐ์ด ๋ฐ๋ก ์ฝ์ด ์
ํ ๋ฒ์ค๋ฅผ ํ ์ ์๋ ์ ์ผ ๋ฆ์ ์๊ฐ์ด ๋๊ฒ ๋๋ค.
๋ด๋ฆผ์ฐจ์์ผ๋ก ํ์ธํ๋ค๋ณด๋ฉด, crew
์ ์๊ฐ์ด ๊ฒน์น๋ ๊ฒฝ์ฐ๊ฐ ์๊ธฐ๊ฒ ๋๋ ๋ฐ, ํด๋น ๋ฌธ์ ํ์ด์ ์ฌ์ฉ๋ ์ฌ์ ํ์ ๊ฒฝ์ฐ ์ค๋ณต์ ํ์ฉํ์ง ์์ ๋ฌธ์ ๊ฐ ์๊ธด๋ค. ๋ฐ๋ผ์ ์ด๋ฅผ ํํผํ๊ธฐ ์ํด ์๋ก์ด ํจ์๋ฅผ ์์ฑํ๋ค.
def duplicateTime(c,integrate):
if not c in integrate.keys():
return c
else:
return duplicateTime(c + 0.001, integrate)
์ธ์๋ก integrate
๋ผ๋ ๋์
๋๋ฆฌ ์๋ฃํ์ ๋ฃ์ key๊ฐ(์๊ฐ)๊ณผ ํ์ฌ for-loop๋ฅผ ๋๊ณ ์๋ integrate
๋ผ๋ ๋์
๋๋ฆฌ ์๋ฃํ์ ๋ฃ๊ณ , ๋ง์ผ ์๊ฐ ๊ฐ์ด ํ์ฌ ๋์
๋๋ฆฌ ์๋ฃํ์ธ integrate
์ ์๋ค๋ฉด ์ฌ๊ท๋ฅผ ํตํด 0.001์ ๋ํ๋ ๋ฐฉ์์ด๋ค. ์ด๋ ๊ฒ ์ฝ๋๋ฅผ ์ง๊ฒ ๋๋ฉด, {540: 'crew', 540.001: 'crew', 540.002: 'crew', 540.0029999999999: 'crew', 541: 'con', 540.0039999999999: 'shuttle', 541.001: 'shuttle'}
์ด๋ฐ ์์ผ๋ก ์ ์ฅ๋์ด ๊ทธ ์์์ ์ค๋ณต์ ํผํ ์ ์๋ค.
for time in sorted(integrate.keys()):
if 'crew' == integrate[time]:
waiting_line.append('crew')
elif 'con' == integrate[time]:
waiting_line.append('con')
elif 'shuttle' == integrate[time]:
waiting_line = waiting_line[m:]
๊ทธ๋ฆฌ๊ณ integrate
๋์
๋๋ฆฌ ์๋ฃํ์ ์ด์ฉํด waiting_line
์ crew
์ con
์ ๋ฃ์ด ์ค์ ๋ง๋ค๊ณ shuttle
์ด ์ค๋ฉด ์ค์ ์์๋ ๊ตฌ์กฐ๋ก ์ง ๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก waiting_line
์๋ ํด๋น ์ํ์ con ์์น์ผ ๋, ๋ฒ์ค๋ฅผ ๋ชป ํ ์ธ์์ด ๋์ค๊ฒ ๋ ๊ฒ ์ด๋ค. ์ด์ waiting_line
์ ์ฝ์ด ์๋ค๋ฉด ์ฝ์ด ์ ์์ ์ผ๋ก ๋ฒ์ค๋ฅผ ํ๊ฒ ๋ ๊ฐ์ฅ ๋ฆ์ ์๊ฐ์ด๋ผ๋ ๋ป์ด๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ๋ฐํํ๋ฉด ๋ฌธ์ ๋ ํด๊ฒฐ๋๋ค.
if not 'con' in waiting_line:
return minuteToTime(con)
๐ ๋ ์ฌ๊ฒจ ๋ณผ ๋งํ ํ์ด
def solution(n, t, m, timetable):
answer = ''
timetable = [ int(time[:2])*60 + int(time[3:5]) for time in timetable ]
timetable.sort()
for i in range(n):
last_time = 540 + (n - 1) * t
if len(timetable) < m:
return '%02d:%02d' % (last_time // 60, last_time % 60)
if i == n - 1:
if timetable[0] > last_time:
return '%02d:%02d' % (last_time // 60, last_time % 60)
time = timetable[m - 1] - 1
return '%02d:%02d' % (time // 60, time % 60)
for j in range(m-1, -1, -1):
bus_arrive = 540 + i * t
if timetable[j] <= bus_arrive:
del timetable[j]
์ด ํ์ด๋ timetable
์ ์ง์๊ฐ๋ ๋ฐฉ์์ผ๋ก ํ์๋ค.
์ฒซ ๋ฒ์งธ๋ก ์ฒดํฌํ ๊ฑด timetable
์ ๊ธธ์ด๊ฐ m
๋ณด๋ค ์์๊ฐ์ด๋ค. ์์ ๊ฒฝ์ฐ ๋ฒ์ค๊ฐ ์ถฉ๋ถํ ๋ง์ ๊ฒฝ์ฐ๋ก ๋ฒ์ค์ ๋ง์ง๋ง ์๊ฐ์ด ๋ต์ด ๋๋ค.
๋ ๋ฒ์งธ๋ก ์ฒดํฌํ ๊ฑด ํด๋น ์ํ์ด ๋ง์ง๋ง์ธ ์ง์ ๋ํ ๊ฒ์ด๋ค. ๋จ์ ์ธ์ ์ค ์๊ฐ์ด ๊ฐ์ฅ ์์ timetable[0]
๊ฐ ๋ฒ์ค ๋ง์ง๋ง ์๊ฐ๋ณด๋ค ์ปค๋ ์ญ์ ๋ฒ์ค์ ๋ง์ง๋ง ์๊ฐ์ด ๋ต์ด ๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด, ๋ง์ง๋ง์ ๋ฒ์ค์ ํ๋ ํฌ๋ฃจ์ ์๊ฐ ๋ณด๋ค 1์ด ์์ ๊ฐ์ ๋ฐํํ๋ฉด ๋๋ค.
๊ทธ๋ฆฌ๊ณ ํด๋น ๋ฒ์ค ์๊ฐ ์ดํ์ ํด๋นํ๋ timetable
์ ํด๋นํ๋ ์ธ์์ ์ง์ฐ๋ for-loop์ธ๋ฐ ์ฌ๊ธฐ์ ํ ๊ฐ์ง ํน์ดํ ๋ฐฉ์์ ์ผ๋ค. range(m-1, -1, -1)
์ ์ฌ์ฉํด์ 0์์ m-1๊น์ง ์ ํด๋นํ๋ timetable
์ ๋น๊ตํ๋ ๋ฐ ๊ฑฐ๊พธ๋ก ๋น๊ตํ๋ฉด์ timetable์ ์ง์๊ฐ๋ค. ์ด ๋ฐฉ์์ ์ผ๋ฐ์ ์ธ range์ ์ฌ์ฉ๋ฒ์ฒ๋ผ range(0, m-1)
๋ก ํ๊ฒ ๋๋ฉด ์ธ๋ฑ์ค๊ฐ ์ ์ ๋ฐฐ์ด์ ์์ ๋ถํฐ ์ง์ฐ๊ฒ ๋๋ฏ๋ก timetable
์ด ์์น ์์ ๊ฒฐ๊ณผ ๊ฐ์ ๊ฐ๊ฒ ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก for in loop
์์ ๋ฐฐ์ด์ ์ ๊ฑฐํ๋ ํ๋์ ํ์ง ์๋ ๋ฐ, ์ด๋ ๊ฒ ํ๊ฒ ๋๋ฉด for in loop๋ฅผ ์ด์ฉํ๋ฉด์ ์ํ๋ ๋ฆฌ์คํธ ๊ฐ์ ์ป์ ์ ์๊ฒ ๋๋ค.
cf. ๋ฌธ์ ํด์์ ๋ง์ ์๊ฐ์ด ๋ค๊ธฐ ๋๋ฌธ์, ๋์ฌ ์ ์๋ ๊ฒฝ์ฐ์ ์ ์ต๋ํ ๋นจ๋ฆฌ ๋๋๋ ๊ฒ ์ด ๋ฌธ์ ์ ํต์ฌ์ด๋ค. ๊ทธ๋ ๊ฒ ํ์ง ๋ชปํ ๋ค๋ฉด ๋ด ํ์ด ๋ฐฉ๋ฒ์ฒ๋ผ ๋ชจ๋ ๊ฐ๋ฅ์ฑ์ ์ํํด๋ณด๋ ์ ๋ฐ์ ์๋ค.
'Algorithm > Problem Solving' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋๊ธ
์ด ๊ธ ๊ณต์ ํ๊ธฐ
-
๊ตฌ๋
ํ๊ธฐ
๊ตฌ๋ ํ๊ธฐ
-
์นด์นด์คํก
์นด์นด์คํก
-
๋ผ์ธ
๋ผ์ธ
-
ํธ์ํฐ
ํธ์ํฐ
-
Facebook
Facebook
-
์นด์นด์ค์คํ ๋ฆฌ
์นด์นด์ค์คํ ๋ฆฌ
-
๋ฐด๋
๋ฐด๋
-
๋ค์ด๋ฒ ๋ธ๋ก๊ทธ
๋ค์ด๋ฒ ๋ธ๋ก๊ทธ
-
Pocket
Pocket
-
Evernote
Evernote
๋ค๋ฅธ ๊ธ
-
[ํ๋ก๊ทธ๋๋จธ์ค] ๐ ์ถ์ ํธ๋ํฝ - [1์ฐจ] 2018 ์นด์นด์ค ๋ธ๋ผ์ธ๋ ์ฑ์ฉ / ํ์ด์ฌ / python / KAKAO BLIND RECRUITMENT
[ํ๋ก๊ทธ๋๋จธ์ค] ๐ ์ถ์ ํธ๋ํฝ - [1์ฐจ] 2018 ์นด์นด์ค ๋ธ๋ผ์ธ๋ ์ฑ์ฉ / ํ์ด์ฌ / python / KAKAO BLIND RECRUITMENT
2019.02.01 -
[BOJ] ๐ธ N-Queens / ํ์ด์ฌ
[BOJ] ๐ธ N-Queens / ํ์ด์ฌ
2019.02.01 -
[ํ๋ก๊ทธ๋๋จธ์ค] ์ด์ํ ๋ฌธ์ ๋ง๋ค๊ธฐ / ํ์ด์ฌ
[ํ๋ก๊ทธ๋๋จธ์ค] ์ด์ํ ๋ฌธ์ ๋ง๋ค๊ธฐ / ํ์ด์ฌ
2019.01.31 -
[ํ๋ก๊ทธ๋๋จธ์ค] ๐จโ๐ N์ผ๋ก ํํ / ํ์ด์ฌ
[ํ๋ก๊ทธ๋๋จธ์ค] ๐จโ๐ N์ผ๋ก ํํ / ํ์ด์ฌ
2019.01.31