2019 KAKAO BLIND RECRUITMENT - Lv1.
๐ต ๋ฌธ์
https://school.programmers.co.kr/learn/courses/30/lessons/42889
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๐ ํ์ด
๋ฌธ์ ๋ฅผ ๋ถ์ํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
N: ์ ์ฒด ์คํ ์ด์ง์ ๊ฐ์
stages: ๊ฒ์์ ์ด์ฉํ๋ ์ฌ์ฉ์์, ํ์ฌ ๋ฉ์ถฐ์๋ ์คํ ์ด์ง ๋ฒํธ๊ฐ ๋ด๊ธด ๋ฐฐ์ด
stages์ ๊ธธ์ด: ์ ์ ์
์คํจ์จ์ ๋ถ๋ชจ: ์ฒ๋ฆฌ ์๋ (๋จ์) ์ ์ ์
์คํจ์จ์ ๋ถ์: ํ์ฌ ์ฒดํฌํ๊ณ ์๋ stage์ ์
๐ก ์ฒซ ๋ฒ์งธ ์์ฑํ ํ์ด ์ฝ๋๋ ์๋์ ๊ฐ์ต๋๋ค.
def getReversedRatioArr(arr):
arr.sort(key=lambda ratio: (-ratio[1], ratio[0])) # 1st ์คํจ์จ, 2nd ์คํ
์ด์ง ์์ ์์ผ๋ก ์ ๋ ฌ
result = []
for tuple in arr:
result.append(tuple[0])
return result
def solution(N, stages):
stages = sorted(stages, reverse=True) # ์ ๋ ฌ, ๊ธฐ์ค ์ ํ ๋ ์ฉ์ดํ๊ณ ์ ๋ค๋ง ๋ณด๊ธฐ ์ํจ (200,000)
failRatio = []
for stage in range(1, N + 1): # ์คํ
์ด์ง ๋ณ๋ก ์ดํด๋ณด๊ธฐ (500)
if stage != stages[-1]: # ํด๋น ์คํ
์ด์ง์ ๋๋ฌํ ์ ์ ๊ฐ ์๋ ๊ฒฝ์ฐ: ์คํจ์จ 0
failRatio.append((stage, 0))
continue
if stages[0] == stages[-1]: # ํด๋น ์คํ
์ด์ง์ ๋๋ฌํ ์ ์ ์๋๋ฐ (์์์ ๊ฑธ๋ฌ์ง), ์ ๋ถ ๋ค ํด๋ฆฌ์ด ํ์ง ๋ชปํ ๊ฒฝ์ฐ: ์คํจ์จ 1
failRatio.append((stage, 1))
continue
cnt = 0 # ํด๋น ์คํ
์ด์ง ํด๋ฆฌ์ด ํ์ง ๋ชปํ ์ ์ ์
for i in range(len(stages) - 1, -1, -1):
if stages[i] != stage:
break
cnt += 1
failRatio.append((stage, cnt / len(stages)))
stages = stages[:-1 * cnt]
return getReversedRatioArr(failRatio)
stage๋ฅผ ๋๋ฉด์ ๋ฐ๋ณต๋ฌธ ๋ด๋ถ์์ ํด๋ฆฌ์ดํ์ง ๋ชปํ ์ ์ ์๋ฅผ ์ธ๊ณ ์์ต๋๋ค. ํ ๋จ๊ณ๊ฐ ์ง๋ ๋๋ง๋ค ํด๋ฆฌ์ดํ์ง ๋ชปํ ์ ์ ๋ฅผ ์ ๊ฑฐํด์ฃผ๊ณ ์์ด์ ๋ฌธ์ ๋ฅผ ๋ง์ถ๋๋ฐ ์ฃผ์ด์ง ํ ์ผ๋ ํต๊ณผํ๊ธดํ์ง๋ง,
๋๋ต 500 * 200,000๊น์ง ์๊ฐ ๋ณต์ก๋๊ฐ ๋ธ ์ ์์ด์ ํด๋น ์คํ ์ด์ง๋ฅผ ํด๋ฆฌ์ดํ์ง ๋ชปํ ์ ์ ์๊ฐ ๋ง์ ๊ฒฝ์ฐ (์๋ ๋ฐ๋ณต๋ฌธ์์ ๊ฑธ๋ฆฌ๋๊ฒ ๋ง์ ๊ฒฝ์ฐ) ์ํํ๊ฒ ๋ค๊ณ ์๊ฐํ์ต๋๋ค. ๐ฅฒ
for i in range(len(stages) - 1, -1, -1):
if stages[i] != stage:
break
cnt += 1

๊ทธ๋์ ๋ฐ๋ณต๋ฌธ์ ์ฌ๋ฌ ๋ฒ ์ธ ์๋ ์์ด๋ ์ค์ฒฉํด์ ์ฌ์ฉํ์ง๋ ๋ง์์ผ ํ ๊ฒ ๊ฐ์, ํด์ ํ ์ด๋ธ๊ณผ ๊ฐ์ ๋ฐฉ์์ผ๋ก ๊ฐ ๋จ๊ณ๋ณ๋ก ์ ์ ์๋ฅผ ์ธ๊ณ ๋ฉ๋ชจํด๋๋ ๋ฐฉ์์ ์ ํํ์ต๋๋ค.
๐ก ๋ ๋ฒ์งธ ์์ฑํ ํ์ด ์ฝ๋๋ ์๋์ ๊ฐ์ต๋๋ค.
def getReversedRatioArr(arr):
arr.sort(key=lambda ratio: (-ratio[1], ratio[0])) # 1st ์คํจ์จ, 2nd stage๋ก ์ ๋ ฌ
result = []
for tuple in arr:
result.append(tuple[0])
return result
def refactorSolution(N, stages):
totalUserNum = len(stages)
failRatio = [0] * (N + 1) # 1๋ถํฐ N๊น์ง (์ธ๋ฑ์ค 0 ๋น์๋ )
# ๊ฐ ์คํ
์ด์ง๋ง๋ค ๋ช ๋ช
์๋์ง ์ฒดํฌ, ์ธ๋ฑ์ค: key, ์์: value ๊ผด์ ํด์ ํ
์ด๋ธ์ฒ๋ผ ์ฒ๋ฆฌ
for stage in stages:
# ๋งํ๊น์ง ๋ค ๊นฌ ์ ์ ๋ ์คํจ์จ์ ์ํฅ X
if stage == N + 1:
continue
failRatio[stage] += 1 # ์คํ
์ด์ง๋ณ ์ธ์ ์ฒดํฌ๋ฅผ ์ํจ
# ๋จ๊ณ๋ง๋ค ์คํจ์จ ์ฒดํฌ (1๋จ๊ณ ~ N๋จ๊ณ)
for i in range(1, N + 1):
currStageUser = failRatio[i]
if totalUserNum == 0:
break
failRatio[i] = (i, failRatio[i] / totalUserNum)
totalUserNum -= currStageUser
# totalUserNum์ด 0์ด ๋์ด ์คํจ์จ์ ๋น์จ๊ผด๋ก ๋ํ๋ด์ง ๋ชปํ ์์๋ค ์ฒ๋ฆฌ
for i in range(N + 1):
if failRatio[i] == 0:
failRatio[i] = (i, 0)
return getReversedRatioArr(sorted(failRatio[1:], key=lambda ratio: (-ratio[1], ratio[0])))

'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [ํ๋ก๊ทธ๋๋จธ์ค] ์ซ์ ๋ฌธ์์ด๊ณผ ์๋จ์ด (์นด์นด์ค ์ฑ์ฉ์ฐ๊ณํ ์ธํด์ญ) - Python (0) | 2023.02.23 |
|---|---|
| [ํ๋ก๊ทธ๋๋จธ์ค] ์ฑ๊ฒฉ ์ ํ ๊ฒ์ฌํ๊ธฐ (KAKAO TECH INTERNSHIP) - Python (0) | 2023.02.23 |
| [ํ๋ก๊ทธ๋๋จธ์ค] ๋คํธ ๊ฒ์ (KAKAO BLIND RECRUITMENT) - Python (0) | 2023.02.22 |
| [ํ๋ก๊ทธ๋๋จธ์ค] ์ฒด์ก๋ณต - Python (0) | 2022.12.04 |
| [BOJ] ํด๋ฆฌ์ค๋ฏธ๋ ธ - Python (0) | 2022.12.04 |