Algorithm

[ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค] ์‹คํŒจ์œจ (KAKAO BLIND RECRUITMENT) - Python

lerrybe 2023. 2. 23. 01:31

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])))