๋ฌธ์ ์ค๋ช
์ํผ ๊ฒ์ ๊ฐ๋ฐ์ ์ค๋ ๋ฆฌ๋ ํฐ ๊ณ ๋ฏผ์ ๋น ์ก๋ค. ๊ทธ๋ ๊ฐ ๋ง๋ ํ๋์ฆ ์ค์ฒ์ฑ์ด ๋์ฑ๊ณต์ ๊ฑฐ๋์ง๋ง, ์์ฆ ์ ๊ท ์ฌ์ฉ์์ ์๊ฐ ๊ธ๊ฐํ ๊ฒ์ด๋ค. ์์ธ์ ์ ๊ท ์ฌ์ฉ์์ ๊ธฐ์กด ์ฌ์ฉ์ ์ฌ์ด์ ์คํ ์ด์ง ์ฐจ์ด๊ฐ ๋๋ฌด ํฐ ๊ฒ์ด ๋ฌธ์ ์๋ค.
์ด ๋ฌธ์ ๋ฅผ ์ด๋ป๊ฒ ํ ๊น ๊ณ ๋ฏผ ํ ๊ทธ๋ ๋ ๋์ ์ผ๋ก ๊ฒ์ ์๊ฐ์ ๋๋ ค์ ๋์ด๋๋ฅผ ์กฐ์ ํ๊ธฐ๋ก ํ๋ค. ์ญ์ ์ํผ ๊ฐ๋ฐ์๋ผ ๋๋ถ๋ถ์ ๋ก์ง์ ์ฝ๊ฒ ๊ตฌํํ์ง๋ง, ์คํจ์จ์ ๊ตฌํ๋ ๋ถ๋ถ์์ ์๊ธฐ์ ๋น ์ง๊ณ ๋ง์๋ค. ์ค๋ ๋ฆฌ๋ฅผ ์ํด ์คํจ์จ์ ๊ตฌํ๋ ์ฝ๋๋ฅผ ์์ฑํ๋ผ.
์ ์ฒด ์คํ ์ด์ง์ ๊ฐ์ N, ๊ฒ์์ ์ด์ฉํ๋ ์ฌ์ฉ์๊ฐ ํ์ฌ ๋ฉ์ถฐ์๋ ์คํ ์ด์ง์ ๋ฒํธ๊ฐ ๋ด๊ธด ๋ฐฐ์ด stages๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์คํจ์จ์ด ๋์ ์คํ ์ด์ง๋ถํฐ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์คํ ์ด์ง์ ๋ฒํธ๊ฐ ๋ด๊ฒจ์๋ ๋ฐฐ์ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ๋ผ.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
N | stages | result |
---|---|---|
5 | [2, 1, 2, 6, 2, 4, 3, 3] | [3,4,2,1,5] |
4 | [4,4,4,4,4] | [4,1,2,3] |
์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
1๋ฒ ์คํ
์ด์ง์๋ ์ด 8๋ช
์ ์ฌ์ฉ์๊ฐ ๋์ ํ์ผ๋ฉฐ, ์ด ์ค 1๋ช
์ ์ฌ์ฉ์๊ฐ ์์ง ํด๋ฆฌ์ดํ์ง ๋ชปํ๋ค. ๋ฐ๋ผ์ 1๋ฒ ์คํ
์ด์ง์ ์คํจ์จ์ ๋ค์๊ณผ ๊ฐ๋ค.
2๋ฒ ์คํ ์ด์ง์๋ ์ด 7๋ช ์ ์ฌ์ฉ์๊ฐ ๋์ ํ์ผ๋ฉฐ, ์ด ์ค 3๋ช ์ ์ฌ์ฉ์๊ฐ ์์ง ํด๋ฆฌ์ดํ์ง ๋ชปํ๋ค. ๋ฐ๋ผ์ 2๋ฒ ์คํ ์ด์ง์ ์คํจ์จ์ ๋ค์๊ณผ ๊ฐ๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก ๋๋จธ์ง ์คํ ์ด์ง์ ์คํจ์จ์ ๋ค์๊ณผ ๊ฐ๋ค.
๊ฐ ์คํ ์ด์ง์ ๋ฒํธ๋ฅผ ์คํจ์จ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
์ ์ถ๋ ฅ ์ #2
๋ชจ๋ ์ฌ์ฉ์๊ฐ ๋ง์ง๋ง ์คํ ์ด์ง์ ์์ผ๋ฏ๋ก 4๋ฒ ์คํ ์ด์ง์ ์คํจ์จ์ 1์ด๋ฉฐ ๋๋จธ์ง ์คํ ์ด์ง์ ์คํจ์จ์ 0์ด๋ค.
๋ฌธ์ ํ์ด
def solution(N, stages):
c = {}
user = len(stages)
for i in range(1,N+1):
c[i] = 0
if i in stages: #์คํ
์ด์ง์ ํด๋น๋ฒ์งธ ์คํ
์ด์ง๊ฐ ์๋ค๋ฉด
cnt = stages.count(i) #์คํ
์ด์ง๋ง๋ค ์ฌ๋๋ค ์
faile = cnt/user #์คํ
์ด์ง๋ง๋ค ์คํจ์จ
user -= cnt
if cnt != None: #c dictionary์ ์คํจ์จ๊ณผ ์ธ๋ฑ์ค ์ถ๊ฐ
c[i] = faile
c = sorted(c.items(), key=lambda x: x[1], reverse=True)
answer = []
for i in c:
answer.append(i[0])
return answer
๋ค๋ฅธ ์ฌ๋ ํ์ด
def solution(N, stages):
result = {}
denominator = len(stages)
for stage in range(1, N+1):
if denominator != 0:
count = stages.count(stage)
result[stage] = count / denominator
denominator -= count
else:
result[stage] = 0
return sorted(result, key=lambda x : result[x], reverse=True)