[Programmers] 기능 개발 (Java, Kotlin)

https://programmers.co.kr/learn/courses/30/lessons/42586

코딩테스트 연습 - 기능개발

문제

프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.

또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다. 먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 해야 합니다.

 

접근 아이디어

1. N 번째 데이터를 이용하여 term을 구합니다. (term은 제가 정한 변수이며 아래 코드에 포함되어 있습니다)

2. N+1 번째 이후의 데이터를 이용하여 마찬가지로 nextTerm을 구합니다.

3. term과 nextTerm을 비교하여 N 번째가 완료되는 날 완료되는 작업의 개수를 모두 구합니다. 

 

조심해야할 점

term과 nextTerm을 구할 때 올림이 필요한 경우 안필요한 경우를 분기처리하여야 합니다.

 

 

- Java

import java.util.*;

public class Solution {

    public static void main(String[] args) {

        int[] progresses1 = {93, 92, 55};
        int[] speeds1 = {2, 2, 5};

        int[] progresses2 = {95, 90, 99, 99, 80, 99};
        int[] speeds2 = {1, 1, 1, 1, 1, 1};

        System.out.println(new Solution().solution(progresses1, speeds1));
    }

    public int[] solution(int[] progresses, int[] speeds) {
        Queue<Work> queue = new LinkedList<>();

        for(int i=0; i<progresses.length; i++) {
            int progress = progresses[i];
            int speed = speeds[i];
            queue.add(new Work(progress, speed));
        }

        ArrayList<Integer> list = new ArrayList<>();
        while(!queue.isEmpty()) {
            Work work = queue.poll();
            int count = 1;
            int term = getTerm(work.progress, work.speed);
            while(!queue.isEmpty()) {
                Work nextWork = queue.peek();
                int nextTerm = getTerm(nextWork.progress, nextWork.speed);
                if(nextTerm <= term) {
                    queue.poll();
                    count++;
                } else break;
            }

            list.add(count);
        }

        return list.stream().mapToInt(value -> value).toArray();
    }

    public int getTerm(int progress, int speed) {
        if(speed == 1) return 100 - progress;

        int term = (100 - progress);
        return term % speed != 0 ? term + 1 : term;
    }

    //작업량과 속도를 저장하는 클래스
    static class Work {
        int progress;
        int speed;
        Work(int progress, int speed) {
            this.progress = progress;
            this.speed = speed;
        }
    }
}

 

 

- Kotlin

import java.util.*;

class Solution {
    fun solution(progresses: IntArray, speeds: IntArray): IntArray {

        val queue = LinkedList<Work>()
        for (index in progresses.indices) {
            queue.add(Work(progresses[index], speeds[index]))
        }

        val list = ArrayList<Int>()
        while (!queue.isEmpty()) {
            val work = queue.poll()

            var count = 1
            val term = getTerm(work.progress, work.speed)

            while (!queue.isEmpty()) {
                val nextWork = queue.peek()
                val nextTerm = getTerm(nextWork.progress, nextWork.speed)
                if (nextTerm <= term) {
                    queue.poll()
                    count++
                } else break
            }

            list.add(count)
        }

        return list.stream().mapToInt { it }.toArray()
    }

    fun getTerm(progress: Int, speed: Int): Int {
        val term = 100 - progress
        return when (speed) {
            0 -> term
            else -> {
                if (term % speed != 0) term / speed + 1
                else term / speed
            }
        }
    }

    //작업량과 속도를 저장하는 클래스
    class Work(
        val progress: Int,
        val speed: Int
    )
}

 

 

좌(Java 채점 결과), 우(Kotlin 채점 결과)