2019 카카오 실패율 (파이썬 python)

2019 카카오 실패율 (파이썬 python)

 

문제 풀이 및 접근

• input인 stages로 반복문을 돌리는 것과 N을 기준으로 반복문을 돌리는 두 가지 방법으로 풀었습니다.
• 이 문제의 경우 1,...,N 단계까지의 모든 단계마다 실패율을 구해야했으므로 input 으로 받은 stages를 이용하는 것보다는 range(1,N+1) 사용했을 때 예외 처리가 적고 간결하게 짤 수 있었습니다.
• 튜플을 원소로 하는 리스트가 있을 때 그 리스트를 정렬하면 첫 번째 원소부터 마지막 원소까지 순서대로 기준이 되어 정렬되는 것을 이용하기 위해 ( 실패율 , stage )의 튜플로 각 stage 마다의 실패율을 담았습니다.

Code - N을 기준으로 for문

def solution(N,stages):
    result = []
    num = len(stages)
    
    for stage in range(1,N+1):
        if num != 0:
            count = stages.count(stage)
            result.append( (count/num ,stage ) )
            num -= count
        else:
            result.append( (0,stage))
    
    result.sort(key = lambda x: (-x[0],x[1]) )
    return [ x[1] for x in result]

 

Code - input stages을 기준으로 for문 

def solution(N, stages):
    stages.sort()
    
    # best_ranker_stage보다 높은 stage가 있다면 그 stage들에 실패율 = 0 채워넣음
    failure_stage = [] # ( failure_rate , stage )
    best_ranker_stage = stages[-1]
    if best_ranker_stage < N+1:
        for stage in range(best_ranker_stage+1,N+1):
            failure_stage.append(( 0,stage ) )

    num_challenger = len(stages)
    current_stage = 0; prev_stage = 0
    for i in stages:
        # stage 겹치는 경우 다음으로 넘김
        if i == current_stage:
            continue
        else:
            #stages 에서 prev_stage와 current_stage가 연속이 아닐 때 그 사이 stage 실패율을 0 으로 채움
            current_stage = i
            if current_stage - prev_stage != 1:
                for between in range(prev_stage+1,current_stage):
                    failure_stage.append( ( 0 , between ) )
            
            # i가 N+1 일때 처리 (N 깬사람이 있는지 없는지로)
            if current_stage == N+1:
                if current_stage -1 in [x[1] for x in failure_stage ]:
                    break
                else:
                    failure_rate  = stages.count(N) / num_challenger
                    failure_stage.append( (failure_rate, N ))
            # 일반적인 경우의 구현
            else:
                failure_rate  = stages.count(i) / num_challenger
                failure_stage.append( (failure_rate, current_stage))
                num_challenger -= stages.count(i)
            prev_stage = i # prev_stage update

    failure_stage.sort( key = lambda x : (-x[0] , x[1]) )

    return [ x[1] for x in failure_stage ]