프로그래머스 LV2 과제 진행하기

문제 자체는 어렵지 않았다.

• 앞선 작업이 끝나지 않은 상태에서 새로운 작업이 추가되면 멈춘다.
• 보자마자 "스택"이었는데...

근데 이 문제는 삽질을 너무 오래 해서 내가 짠 코드도 이해가 안되고 왜 저렇게 했는지 기억이 나질 않았다. 그래서 예전에 짠 코드를 다시 분석해보았다.

• 작업을 처리하는 부분에서 미리 뭔가를 계산하다보니 비교하는 부분이 엉터리였다.
  • 이전에 저장한 현재 시간보다 작업 시작 시간이 나중이면 현재 시간 갱신
  • 다음 작업 시작 시간보다 현재 시간 + 작업 시간이 작거나 같으면 현재 시간에 작업 시간 더하고 answer에 넣음
  • 다음 작업 시작 시간보다 현재 시간 + 작업 시간이 크면 현재 시간을 다음 작업 시작 시간으로 갱신하고 작업 큐에 남은 작업 시간(현재 시간 + 작업 시간 - 다음 작업 시간)을 넣어줌
  • 다음 작업을 작업 큐에 넣어줌
  • 모든 플랜을 돌면 작업 큐에 남은 작업들 순차적으로 작업하고 answer에 넣음.

저렇게 할 필요가 없이 그냥 한 줄로 세워서 정리하고 다음 작업과 스택을 비교하기를 반복...

• 작업 큐에서 첫 작업을 빼서 스택에 넣음
• (반복) 작업 큐에서 다음 작업을 빼서...
  • 스택에 작업이 있는지 확인
    • 스택에서 빼서 비교하는 작업 시작
  • 스택에 작업이 없으면 
    • 스택에 작업 넣기

def solution(plans):
    answer = []
    
    for i,v in enumerate(plans): # 시간 문자열을 숫자로 변경
        job, t1, t2 = v
        hh,mm = t1.split(":")
        plans[i][1],plans[i][2] = int(hh) * 60 + int(mm), int(t2)

    plans.sort(key=lambda x:x[1]) # 정렬
        
    stack = [] # 스택 초기화
    stack.append(plans[0]) # 스택에 작업 넣기
    
    time = plans[0][1] # 첫 작업 시작 시간
    
    for i in range(1, len(plans)):
        next_time = plans[i][1] # 다음 작업 시작 시간

        while len(stack): # 스택에 작업이 있으면
            job, time_start, time_spend = stack.pop() # 스택에서 작업 꺼내기
            
            if time < time_start: # 현재 시간보다 스택에 있는 작업 시작 시간이 느리면
                time = time_start # 시간 조정
                
            time_finish = time + time_spend # 스택의 작업이 끝나는 시간

            if next_time < time_finish: # 다음 작업 시작 시간이 스택에 있는 작업 완료시간보다 빠르면 
                stack.append([job, time_start, time_finish - next_time]) # 스택에서 꺼낸 작업을 다시 넣고
                time = next_time # 현재 시간은 다음 작업 시작 시간으로 변경
                break # 중지
            else:
                answer.append(job) # 스택의 작업을 완료한다.
                time += time_spend # 현재 시간에 소요 시간을 더한다.
                                   # 스택에 작업이 있으면 계속

        stack.append(plans[i]) # 스택에 작업 넣기

    while len(stack): # 스택에 남은 작업 꺼내서 완료하기
        answer.append(stack.pop()[0])

    return answer
    
정확성  테스트
테스트 1 〉	통과 (0.03ms, 10.4MB)
테스트 2 〉	통과 (0.05ms, 10.4MB)
테스트 3 〉	통과 (0.06ms, 10.3MB)
테스트 4 〉	통과 (0.07ms, 10.3MB)
테스트 5 〉	통과 (0.06ms, 10.3MB)
테스트 6 〉	통과 (0.12ms, 10.4MB)
테스트 7 〉	통과 (0.15ms, 10.4MB)
테스트 8 〉	통과 (0.18ms, 10.3MB)
테스트 9 〉	통과 (0.29ms, 10.6MB)
테스트 10 〉	통과 (0.25ms, 10.4MB)
테스트 11 〉	통과 (0.42ms, 10.3MB)
테스트 12 〉	통과 (0.75ms, 10.4MB)
테스트 13 〉	통과 (1.08ms, 10.4MB)
테스트 14 〉	통과 (1.47ms, 10.6MB)
테스트 15 〉	통과 (2.56ms, 10.8MB)
테스트 16 〉	통과 (0.03ms, 10.3MB)
테스트 17 〉	통과 (0.03ms, 10.3MB)
테스트 18 〉	통과 (0.03ms, 10.3MB)
테스트 19 〉	통과 (0.04ms, 10.4MB)
테스트 20 〉	통과 (0.28ms, 10.3MB)
테스트 21 〉	통과 (0.27ms, 10.4MB)
테스트 22 〉	통과 (1.40ms, 10.6MB)
테스트 23 〉	통과 (2.76ms, 10.8MB)
테스트 24 〉	통과 (1.77ms, 10.8MB)

고수의 풀이... 뭔가 되게 간단해져 버렸다.

def solution(plans):
    plans = sorted(map(lambda x: [x[0], int(x[1][:2]) * 60 + int(x[1][3:]), int(x[2])], plans), key=lambda x: -x[1])

    lst = []
    while plans:
        x = plans.pop()
        for i, v in enumerate(lst):
            if v[0] > x[1]:
                lst[i][0] += x[2]
        lst.append([x[1] + x[2], x[0]])
    lst.sort()

    return list(map(lambda x: x[1], lst))
    
정확성  테스트
테스트 1 〉	통과 (0.03ms, 10.3MB)
테스트 2 〉	통과 (0.05ms, 10.2MB)
테스트 3 〉	통과 (0.04ms, 10.3MB)
테스트 4 〉	통과 (0.07ms, 10.3MB)
테스트 5 〉	통과 (0.08ms, 10.3MB)
테스트 6 〉	통과 (0.11ms, 10.3MB)
테스트 7 〉	통과 (0.52ms, 10.3MB)
테스트 8 〉	통과 (0.33ms, 10.4MB)
테스트 9 〉	통과 (1.95ms, 10.4MB)
테스트 10 〉	통과 (1.19ms, 10.4MB)
테스트 11 〉	통과 (3.35ms, 10.3MB)
테스트 12 〉	통과 (28.39ms, 10.7MB)
테스트 13 〉	통과 (20.49ms, 10.7MB)
테스트 14 〉	통과 (84.96ms, 10.7MB)
테스트 15 〉	통과 (89.17ms, 10.6MB)
테스트 16 〉	통과 (0.04ms, 10.5MB)
테스트 17 〉	통과 (0.03ms, 10.3MB)
테스트 18 〉	통과 (0.04ms, 10.3MB)
테스트 19 〉	통과 (0.06ms, 10.3MB)
테스트 20 〉	통과 (0.86ms, 10.2MB)
테스트 21 〉	통과 (0.93ms, 10.3MB)
테스트 22 〉	통과 (85.63ms, 10.6MB)
테스트 23 〉	통과 (87.52ms, 10.6MB)
테스트 24 〉	통과 (81.80ms, 10.6MB)

난 아직도 갈 길이 멀구나...