DevYoon
[ํ๋ก๊ทธ๋๋จธ์ค] ์คํจ์จ (Python) ๋ณธ๋ฌธ
link ๐ https://school.programmers.co.kr/learn/courses/30/lessons/42889
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๐ฌ ์๊ฐ์ด๊ณผ ๋ฐ์ ์ฝ๋
- ์ฒ์์๋ ์คํ ์ด์ง๋ณ๋ก ๋๋ฌํ ์ฌ๋๊ณผ ๋์ ์ค์ธ ์ฌ๋์ ๊ฐ๊ฐ arrival๊ณผ challenge ๋ฐฐ์ด์ ๊ธฐ๋กํ๊ณ , ๋์ ๋๋ฆฌ ํํ๋ก ์คํจ์จ์ ๊ตฌํด์ฃผ์๋ค.
- ๊ทธ๋ฆฌ๊ณ ์ด๋ฅผ ๋ฐฐ์ด๋ก ๋ณํํ์ฌ ์กฐ๊ฑด์ ๋ง๊ฒ ์คํจ์จ ๋ด๋ฆผ์ฐจ์, ์คํ ์ด์ง ์ซ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ํ answer์ ์คํ ์ด์ง ์ซ์๋ง append ํด์ฃผ์๋ค.
- ๊ทธ๋ฌ๋ ์๊ฐ์ด๊ณผ๋ฅผ ๋ฐ์๋คใ ใ
def solution(N, stages):
answer = []
arrival = [0]*(N+1)
challenge = [0]*(N+1)
fail = {}
# stages๋ฅผ ์ํํ๋ฉด์ ๋๋ฌํ ์คํ
์ด์ง์ ํ์ฌ ๋์ ์ค์ธ ์คํ
์ด์ง๋ฅผ ์นด์ดํธํด์ค๋ค.
for stage in stages:
# stage๊ฐ N+1์ผ ๊ฒฝ์ฐ limit์ stage๋ก ๋๋ค => 1๋ถํฐ N๊น์ง ์ฒดํฌ
if stage == N+1:
limit = stage
# ๊ทธ ์ธ์ ๊ฒฝ์ฐ, limit์ stage+1๋ก ๋๋ค => 1๋ถํฐ stage๊น์ง ์ฒดํฌ
else:
limit = stage+1
for num in range(1, limit):
arrival[num] += 1
# ๋ชจ๋ ์คํ
์ด์ง๋ฅผ ํต๊ณผํ ๊ฒฝ์ฐ๊ฐ ์๋๋ผ๋ฉด ์คํ
์ด์ง ๋ณ๋ก ๋์ ์ค์ธ ์ ์ ์นด์ดํธ
if stage != N+1:
challenge[stage] += 1
# ์คํจ์จ ๊ตฌํ๊ธฐ => ๋์ ์ / ๋๋ฌ์
for num in range(1, N+1):
fail[num] = challenge[num] / arrival[num]
# ๊ฐ์ฒด๋ฅผ ๋ฐฐ์ด๋ก ๋ณํ
fail_array = list(fail.items())
# ์คํจ์จ ์์ผ๋ก ๋ด๋ฆผ์ฐจ์, ์คํ
์ด์ง ์ซ์ ์์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
fail_array.sort(key=lambda x : (-x[1], x[0]))
# ์คํ
์ด์ง ์ซ์๋ง ์ฐจ๋ก๋ก answer์ append
for stage_num in fail_array:
answer.append(stage_num[0])
return answer
๐ฌ ํต๊ณผํ ์ฝ๋
- ์๊ฐ๊ณผ ๊ตฌ๊ธ๋ง์ ํตํด ๋ก์ง์ ์์ ํด๋ณด์๋ค. ์ ์ ์(stages์ ๊ธธ์ด)๋ฅผ length๋ก ์ ์ธํ๊ณ , 1๋ถํฐ N๊น์ง ๊ฐ ์คํ ์ด์ง์ ์คํจ์จ์ ๋ฐ๋ก ๊ตฌํด์ฃผ์๋ค. ๊ทธ๋ฆฌ๊ณ ์คํจ์จ์ด 0์ ๋๋๋ค๋ฉด, ์ ์ ์์์ ๋์ ์ค์ธ ์ฌ๋ ์๋ฅผ ๋นผ์ฃผ์๋ค.
- ๊ทธ ํ ์คํจ์จ์ ๋ด์ ๋์ ๋๋ฆฌ๋ฅผ ๋ฐฐ์ด๋ก ๋ณํํ๊ณ , ์ ๋ ฌ ํ ์คํ ์ด์ง ์ซ์๋ง answer์ append ํด์ฃผ๋ ๊ฒ์ ์์ ๋ก์ง๊ณผ ๋์ผํ๋ค.
def solution(N, stages):
answer = []
fail = {}
length = len(stages)
# ์คํจ์จ์ด 0 ์ด๊ณผ์ด๋ฉด length์์ ํด๋น ๋จ๊ณ์ ๋์ ์ค์ธ ์ฌ๋ ์ ๋นผ๊ธฐ
for num in range(1, N+1):
if length != 0:
rate = stages.count(num) / length
fail[num] = rate
if rate > 0:
length -= stages.count(num)
else:
fail[num] = 0
# ๊ฐ์ฒด๋ฅผ ๋ฐฐ์ด๋ก ์ ํํ ํ, ์คํจ์จ ๋ด๋ฆผ์ฐจ์ & ์คํ
์ด์ง ์ซ์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
fail_array = list(fail.items())
fail_array.sort(key=lambda x:(-x[1], x[0]))
# ์คํ
์ด์ง ์ซ์๋ง answer์ append
for item in fail_array:
answer.append(item[0])
return answer