8-wonjunYou

[wonjunYou]

🔗 문제 링크

과제 진행하기

문제 설명

과제를 받은 루는 다음과 같은 순서대로 과제를 진행합니다.

• 과제는 시작하기로 한 시각이 되면 시작합니다.
• 새로운 과제를 시작할 시각이 되었을 때, 기존에 진행 중이던 과제가 있다면 진행 중이던 과제를 멈추고 새로운 과제를 시작합니다.
• 진행중이던 과제를 끝냈을 때, 잠시 멈춘 과제가 있다면, 멈춰둔 과제를 이어서 진행합니다.
• 만약, 과제를 끝낸 시각에 새로 시작해야 되는 과제와 잠시 멈춰둔 과제가 모두 있다면, 새로 시작해야 하는 과제부터 진행합니다.
• 멈춰둔 과제가 여러 개일 경우, 가장 최근에 멈춘 과제부터 시작합니다.

과제를 끝낸 순서대로 이름을 배열에 담아 return 하는 solution을 구하라

입력값

3 ≤ plans의 길이 ≤ 1,000
plans의 원소는 [name, start, playtime]의 구조로 이루어져 있습니다.

• name : 과제의 이름
• start : 과제 시작 시간
  -> "hh:mm"의 형태로 "00:00" ~ "23:59" 사이의 시간값만 들어가 있습니다.
  -> 모든 과제의 시작 시각은 달라서 겹칠 일이 없습니다.
• playtime : 과제를 마치는데 걸리는 시간을 의미하며, 단위는 분이다. (1 ~ 100)

✔️ 소요된 시간

25분

✨ 수도 코드

요새 프로그래머스 lv2 ~ 3 중에 아무거나 붙잡고 풀기 시작했습니다! 생각보다 쉬운 문제였지만 PR 진도를 쫓아가기 위해 그냥 한번 적어보도록 하겠습니다..!

일단 과제 진행 순서를 보면
시각에 맞게 진행을 하되, 기본적으로 새로운 과제 -> 시간이 뜨면 최근에 멈춘 과제 순서대로 진행하는 것을 알 수 있습니다.
해당 대목에서 스택임을 바로 캐치할 수 있었습니다.

이후 크게 두가지 케이스로 나눌 수 있습니다.

1. 다음 과제와 현재 과제 시작 시간의 차이(playtime_difference)가 현재 과제 진행 시간(playtime)보다 짧은 경우
   -> 시간이 부족하므로 해당 과제는 남는 시간만큼 stack에 넣습니다.
2. 그렇지 않은 경우, 시간이 중간에 뜨는 상태이므로 stack에서 pop() 연산을 이용해 하나씩 기존 과제들을 수행하도록 합니다.
   만약 기존 과제 하나를 수행하지 못한 경우 잔여 시간을 계산 후 스택에 다시 넣어주는 과정도 잊지 않아야 합니다!

최종 코드

def solution(plans):
    stack = []
    result = []
    
    plans.sort(key=lambda x: x[1])
    
    for i in range(len(plans) - 1):
        current_start_time = plans[i][1]
        next_start_time = plans[i + 1][1]
        
        playtime_difference = calculateDifference(current_start_time, next_start_time)
        
        if int(plans[i][2]) > playtime_difference:
            stack.append([plans[i][0], int(plans[i][2]) - playtime_difference])
        else:
            result.append(plans[i][0])
            remaining_time = playtime_difference - int(plans[i][2])
            
            while stack and remaining_time > 0:
                previous_task, previous_time = stack.pop()
                if previous_time > remaining_time:
                    stack.append([previous_task, previous_time - remaining_time])
                    remaining_time = 0
                else:
                    result.append(previous_task)
                    remaining_time -= previous_time
    
    result.append(plans[-1][0])
    
    while stack:
        result.append(stack.pop()[0])
    
    return result

def calculateDifference(current_time, next_time):
    h1, m1 = map(int, current_time.split(":"))
    h2, m2 = map(int, next_time.split(":"))
    
    current_minutes = h1 * 60 + m1
    next_minutes = h2 * 60 + m2
    
    return next_minutes - current_minutes

[janghw0126]

저도 과제를 시작 시간을 기준으로 정렬하고 스택에 넣으면서

1. 현재 과제를 stack에 넣고
2. 반복문을 통해 하고 있던 과제를 비교해서 남은 시간과 과제하는데 걸리는 시간을 비교한 후,
3. 다음 과제까지 남은 시간이 과제하는데 걸린 시간보다 많으면 그만큼 빼고 answer에는 과제의 이름을 추가하고
4. 과제 리스트에 과제 이름과 남은 과제 시간을 저장하는

로직을 바탕으로 코드를 작성하였습니다.
원준님의 수도코드 덕분에 로직을 더 깔쌈하게 정리할 수 있었네요😉

이번 PR도 수고하셨습니다!

[jung0115]

복귀 하셨군요 🎉🎉🎉
저도 비슷하게 풀었습니다! 이번 차시도 수고하셨어요

import java.util.*;

class Solution {
    
    // 시간을 "HH:MM" 형식에서 분 단위로 변환하는 함수
    private int timeToMinutes(String time) {
        String[] parts = time.split(":");
        return Integer.parseInt(parts[0]) * 60 + Integer.parseInt(parts[1]);
    }
    
    public String[] solution(String[][] plans) {
        // 계획을 시작 시간 기준으로 오름차순 정렬
        Arrays.sort(plans, new Comparator<String[]>() {
            @Override
            public int compare(String[] a, String[] b) {
                return timeToMinutes(a[1]) - timeToMinutes(b[1]);
            }
        });

        Stack<String[]> stack = new Stack<>();
        List<String> completedTasks = new ArrayList<>();
        int currentTime = timeToMinutes(plans[0][1]);
        int i = 0;

        while (i < plans.length || !stack.isEmpty()) {
            if (i < plans.length) {
                String[] currentTask = plans[i];
                int startTime = timeToMinutes(currentTask[1]);
                
                // 이전 과제를 완료하지 못했으면 스택에 저장하고 새로운 과제 시작
                while (!stack.isEmpty() && currentTime + Integer.parseInt(stack.peek()[2]) <= startTime) {
                    String[] pausedTask = stack.pop();
                    currentTime += Integer.parseInt(pausedTask[2]);
                    completedTasks.add(pausedTask[0]);  // 과제 완료 기록
                }

                // 현재 시간에 새로운 과제를 시작
                if (currentTime <= startTime) {
                    currentTime = startTime;
                    stack.push(new String[]{currentTask[0], currentTask[1], currentTask[2]});
                    i++;
                } else {
                    // 시간이 겹치면 남은 과제 시간을 업데이트하여 스택에 저장
                    String[] pausedTask = stack.pop();
                    int remainingTime = Integer.parseInt(pausedTask[2]) - (startTime - currentTime);
                    stack.push(new String[]{pausedTask[0], pausedTask[1], String.valueOf(remainingTime)});
                    currentTime = startTime;
                    stack.push(new String[]{currentTask[0], currentTask[1], currentTask[2]});
                    i++;
                }
            }

            // 남은 과제를 처리
            if (i >= plans.length) {
                while (!stack.isEmpty()) {
                    String[] pausedTask = stack.pop();
                    currentTime += Integer.parseInt(pausedTask[2]);
                    completedTasks.add(pausedTask[0]);
                }
            }
        }

        return completedTasks.toArray(new String[0]);
    }
}