ABOUT ME

-

Today
-
Yesterday
-
Total
-
  • 9. 기능 개발
    코딩 테스트/Level 2 2020. 7. 23. 10:32
    반응형

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

    큐 카테고리의 문제입니다.   

    많은 사람이 푼 문제부터 풀고 있는데요.

    4번이 되어야 하는 어렵지 않은 문제인데 놓쳐서 9번.

    난이도가 낮은 만큼 깔끔하게 작성하는 게 좋겠네요. 

     

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

    프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다. 또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 ��

    programmers.co.kr

    파이썬

    def solution(progresses, speeds):
        answer = []
        while progresses:
            for i in range(len(progresses)):
                progresses[i] += speeds[i]
            length = len(progresses)
            while progresses:
                if progresses[0] >= 100:
                    speeds.pop(0)
                    progresses.pop(0)
                else:
                    break
            if length != len(progresses):
                answer.append(length - len(progresses))
        return answer

    시간 개념을 두고 시간을 speeds에 곱하고 progresses에 더하는 방식으로 문제를 풀까 했으나,
    시간 개념 없이 코딩하면 더 깔끔하게 코딩할 수 (변수 하나와 몇 줄을 줄일 수) 있을 것 같아서
    그렇게 문제를 풀어보았습니다.  

    제가 푼 건 아니지만 100에서 progresses를 빼고 speeds로 나누어서 완성 날자를 계산한 뒤에 정리하는 방식이 좋아보이던데요.
    한 번 시도해보시면 좋겠습니다.

    자바 스크립트

    function solution(progresses, speeds) {
        let answer = [];
        while (progresses.length > 0) {
            for (let i = 0; i < progresses.length; i++)
                progresses[i] += speeds[i]
            let prev_length = progresses.length
            while (progresses.length > 0) {
                if (progresses[0] >= 100) {
                    speeds.shift()
                    progresses.shift()
                } else {
                    break
                }
            }
            if (prev_length != progresses.length)
                answer.push(prev_length - progresses.length)
        }
        return answer;
    }

     

    자바

    import java.util.*;
    
    class Solution {
        public int[] solution(int[] progresses, int[] speeds) {
            LinkedList<int[]> progressQue = new LinkedList<>();
            for (int i = 0; i < progresses.length; i++) 
                progressQue.add(new int[]{progresses[i], speeds[i]});
            ArrayList<Integer> answers = new ArrayList<>();
            while (!progressQue.isEmpty()) {
                int queSize = progressQue.size();
                while (progressQue.get(0)[0] < 100)
                    for (int i = 0; i < queSize; i++)
                        progressQue.get(i)[0] += progressQue.get(i)[1];
                while (!progressQue.isEmpty())
                    if (progressQue.get(0)[0] >= 100)
                        progressQue.remove(0);
                    else
                        break;
                if (queSize != progressQue.size()) 
                    answers.add(queSize - progressQue.size());
            }
            return answers.stream().mapToInt(Integer::intValue).toArray();
        }
    }

     

    코틀린

    import java.util.*
    
    class Solution {
        fun solution(progresses: IntArray, speeds: IntArray): IntArray {
            val progressQue = LinkedList<IntArray>()
            for (i in progresses.indices) 
                progressQue.add(intArrayOf(progresses[i], speeds[i]))
            val answers = ArrayList<Int>()
            while (!progressQue.isEmpty()) {
                val queSize = progressQue.size
                while (progressQue[0][0] < 100) 
                    for (i in 0 until queSize) 
                        progressQue[i][0] += progressQue[i][1]
                while (!progressQue.isEmpty()) 
                    if (progressQue[0][0] >= 100) 
                        progressQue.removeAt(0) else break
                if (queSize != progressQue.size) 
                    answers.add(queSize - progressQue.size)
            }
            return answers.toIntArray()
        }
    }

    toIntArray() 너무 좋습니다.~!

    C#

    using System.Collections.Generic;
    
    public class Solution
    {
        public int[] solution(int[] progresses, int[] speeds)
        {
            List<int> prgList = new List<int>(progresses);
            List<int> spdList = new List<int>(speeds);
            List<int> answer = new List<int>();
            while (prgList.Count > 0)
            {
                for (int i = 0; i < prgList.Count; i++)
                    prgList[i] += spdList[i];
                int prevLength = prgList.Count;
                while (prgList.Count > 0)
                {   
                    if (prgList[0] >= 100)
                    {
                        spdList.RemoveAt(0);
                        prgList.RemoveAt(0);
                    }
                    else break;
                }
                if (prevLength != prgList.Count)
                    answer.Add(prevLength - prgList.Count);
            }
            return answer.ToArray(); 
        }
    }

    GO

    func solution(progresses []int, speeds []int) (rtn []int) {
        for len(progresses) > 0 {
            for i := 0; i < len(progresses); i++ {
                progresses[i] += speeds[i]
            }
            over := 0
            for i := 0; i < len(progresses) && progresses[i] >= 100; i++ {
                over = i + 1
            }
            if len(progresses) == over {
                rtn = append(rtn, over)
                break
            }
            if over != 0 {
                rtn = append(rtn, over)
                progresses = progresses[over:]
                speeds = speeds[over:]
            }
        }
        return
    }
    반응형
Designed by Tistory.