모서리 IT 블로그

문제 설명

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.
예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면
1. array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다.
2. 1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다.
3. 2에서 나온 배열의 3번째 숫자는 5입니다.
배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한사항

• array의 길이는 1 이상 100 이하입니다.
• array의 각 원소는 1 이상 100 이하입니다.
• commands의 길이는 1 이상 50 이하입니다.
• commands의 각 원소는 길이가 3입니다.

입출력 예

내 문제풀이

1. commands를 하나 씩 반복문을 수행한다.
2. 한 commands의 첫 번째, 두 번째 원소로 slicing하여 만든 select_list를 생성한다.
3. select_list를 정렬하고 한 commands의 세 번째 원소로 값을 추출하여 answer에 삽입한다.

내 코드 - 파이썬

def solution(array, commands):
    answer = []
    
    for cmd in commands:
        select_list = (array[cmd[0]-1:cmd[1]])
        select_list.sort()
        answer.append(select_list[cmd[2]-1])
    
    return answer

문제 설명

이중 우선순위 큐는 다음 연산을 할 수 있는 자료구조를 말합니다.

이중 우선순위 큐가 할 연산 operations가 매개변수로 주어질 때, 모든 연산을 처리한 후 큐가 비어있으면 [0,0] 비어있지 않으면 [최댓값, 최솟값]을 return 하도록 solution 함수를 구현해주세요.

제한사항

• operations는 길이가 1 이상 1,000,000 이하인 문자열 배열입니다.
• operations의 원소는 큐가 수행할 연산을 나타냅니다.
  - 원소는 “명령어 데이터” 형식으로 주어집니다.
  - 최댓값/최솟값을 삭제하는 연산에서 최댓값/최솟값이 둘 이상인 경우, 하나만 삭제합니다.
• 빈 큐에 데이터를 삭제하라는 연산이 주어질 경우, 해당 연산은 무시합니다.

입출력 예

내 문제풀이

1. 리스트에서 최대, 최소값을 명령어에 따라 계속 찾아 제거해야 하므로, heapq를 사용한다.
2. operations를 반복문을 돌며 하나씩 빼서 확인한다.
3. 명령어의 앞 문자가 I인 경우, heapq(answer)에 값을 추가한다.
4. 이 외 명령어(제거)에 answer이 비어있다면 해당 명령어를 무시한다. 또한 비어있지 않으면 명령어의 뒷 값을 1과 -1로 구분하여 1이면 최대값을 제거, -1이면 최소값을 제거한다.
5. 반복문이 끝난 후 answer에 아직 값이 남아있다면 최대값, 최소값 배열을 반환한다. 
6. answer아 비어있다면 [0,0]을 반환한다.

내 코드 - 파이썬

import heapq
    
def solution(operations):
    answer = []
    
    for op in operations:
        if op.split(" ")[0] == 'I':
            heapq.heappush(answer, int(op.split(" ")[1]))
    
        else:
            if not answer:
                continue
                
            if op.split(" ")[1] == '1':
                answer.pop(-1)
            else:
                answer.pop(0)        
    
    if answer:
        return [max(answer), min(answer)]
    else:
        return [0,0]
       

문제 설명

하드디스크는 한 번에 하나의 작업만 수행할 수 있습니다. 디스크 컨트롤러를 구현하는 방법은 여러 가지가 있습니다. 가장 일반적인 방법은 요청이 들어온 순서대로 처리하는 것입니다.
예를들어
- 0ms 시점에 3ms가 소요되는 A작업 요청 - 1ms 시점에 9ms가 소요되는 B작업 요청 - 2ms 시점에 6ms가 소요되는 C작업 요청
와 같은 요청이 들어왔습니다. 이를 그림으로 표현하면 아래와 같습니다.

한 번에 하나의 요청만을 수행할 수 있기 때문에 각각의 작업을 요청받은 순서대로 처리하면 다음과 같이 처리 됩니다.

- A: 3ms 시점에 작업 완료 (요청에서 종료까지 : 3ms) - B: 1ms부터 대기하다가, 3ms 시점에 작업을 시작해서 12ms 시점에 작업 완료(요청에서 종료까지 : 11ms) - C: 2ms부터 대기하다가, 12ms 시점에 작업을 시작해서 18ms 시점에 작업 완료(요청에서 종료까지 : 16ms)
이 때 각 작업의 요청부터 종료까지 걸린 시간의 평균은 10ms(= (3 + 11 + 16) / 3)가 됩니다.
하지만 A → C → B 순서대로 처리하면

- A: 3ms 시점에 작업 완료(요청에서 종료까지 : 3ms) - C: 2ms부터 대기하다가, 3ms 시점에 작업을 시작해서 9ms 시점에 작업 완료(요청에서 종료까지 : 7ms) - B: 1ms부터 대기하다가, 9ms 시점에 작업을 시작해서 18ms 시점에 작업 완료(요청에서 종료까지 : 17ms)
이렇게 A → C → B의 순서로 처리하면 각 작업의 요청부터 종료까지 걸린 시간의 평균은 9ms(= (3 + 7 + 17) / 3)가 됩니다.
각 작업에 대해 [작업이 요청되는 시점, 작업의 소요시간]을 담은 2차원 배열 jobs가 매개변수로 주어질 때, 작업의 요청부터 종료까지 걸린 시간의 평균을 가장 줄이는 방법으로 처리하면 평균이 얼마가 되는지 return 하도록 solution 함수를 작성해주세요. (단, 소수점 이하의 수는 버립니다)

제한 사항

• jobs의 길이는 1 이상 500 이하입니다.
• jobs의 각 행은 하나의 작업에 대한 [작업이 요청되는 시점, 작업의 소요시간] 입니다.
• 각 작업에 대해 작업이 요청되는 시간은 0 이상 1,000 이하입니다.
• 각 작업에 대해 작업의 소요시간은 1 이상 1,000 이하입니다.
• 하드디스크가 작업을 수행하고 있지 않을 때에는 먼저 요청이 들어온 작업부터 처리합니다.

입출력 예

내 문제풀이

1. jobs를 두번째 인자를 기준으로 오름차순 정렬한다.
2. jobs의 작업들이 남아 있는 동안 반복문을 수행한다.
3. 가장 마지막 작업이 끝난 시간을 final에 저장하며 정렬한 jobs 중 첫번째 인자가 final 보다 작거나 같은지 비교한다.
4. jobs 중 첫번째 인자가 final 보다 작거나 같다면 final과 총 소요 시간을 갱신하고 jobs에서 해당 작업을 삭제한다.
5. 만약 모든 jobs의 첫번째 인자가 final보다 크다면 final을 +1 하고 반복문을 수행한다.
6. 마지막으로 평균 소요시간을 구해야하므로 총 소요시간을 작업 갯수들로 나누고 나머지는 버리기 때문에 int()를  씌워준다.

내 코드 - 파이썬

def solution(jobs):
    answer = 0
    jobs.sort(key=lambda x : x[1])
    final = 0
    job_len = len(jobs)
    
    while(jobs):
        for idx in range (0, len(jobs)):
            if jobs[idx][0] <= final:
                final += jobs[idx][1]
                answer += final-jobs[idx][0]
                jobs.pop(idx)
                break
            
            if idx == len(jobs)-1:
                final+=1
    
    return int(answer//job_len)

문제 설명

매운 것을 좋아하는 Leo는 모든 음식의 스코빌 지수를 K 이상으로 만들고 싶습니다. 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 Leo는 스코빌 지수가 가장 낮은 두 개의 음식을 아래와 같이 특별한 방법으로 섞어 새로운 음식을 만듭니다.
섞은 음식의 스코빌 지수 = 가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)
Leo는 모든 음식의 스코빌 지수가 K 이상이 될 때까지 반복하여 섞습니다.
Leo가 가진 음식의 스코빌 지수를 담은 배열 scoville과 원하는 스코빌 지수 K가 주어질 때, 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 섞어야 하는 최소 횟수를 return 하도록 solution 함수를 작성해주세요.

제한 사항

• scoville의 길이는 2 이상 1,000,000 이하입니다.
• K는 0 이상 1,000,000,000 이하입니다.
• scoville의 원소는 각각 0 이상 1,000,000 이하입니다.
• 모든 음식의 스코빌 지수를 K 이상으로 만들 수 없는 경우에는 -1을 return 합니다.

입출력 예

내 문제풀이

1. scoville과 같은 내용을 갖는 heapq를 생성한다.
2. heap의 첫번째 원소(가장 작은 값)가 K보다 작을 때까지 반복한다.
3. 반복할 때마다 answer+1을 해주고 스코빌 계산 결과를 heap에 추가한다. 이 때 heappop()을 사용해서 값을 꺼내는 동시에 heap에서 삭제한다.
4. heap의 첫 원소가 K보다 같거나 커지면 answer를 return. 그 전에 heap의 길이가 1이 되면 스코빌 지수를 K 이상으로 만들 수 없는 경우이기 때문에 -1을 return.

내 코드 - 파이썬

import heapq

def solution(scoville, K):
    answer = 0
    heap = []
    for i in scoville:
        heapq.heappush(heap, i)
    
    while(heap[0] < K):
        if len(heap) == 1:
            return -1
        answer += 1
        heapq.heappush(heap, heapq.heappop(heap) + heapq.heappop(heap)*2)
        
    return answer

문제 설명

일반적인 프린터는 인쇄 요청이 들어온 순서대로 인쇄합니다. 그렇기 때문에 중요한 문서가 나중에 인쇄될 수 있습니다. 이런 문제를 보완하기 위해 중요도가 높은 문서를 먼저 인쇄하는 프린터를 개발했습니다. 이 새롭게 개발한 프린터는 아래와 같은 방식으로 인쇄 작업을 수행합니다.
1. 인쇄 대기목록의 가장 앞에 있는 문서(J)를 대기목록에서 꺼냅니다. 2. 나머지 인쇄 대기목록에서 J보다 중요도가 높은 문서가 한 개라도 존재하면 J를 대기목록의 가장 마지막에 넣습니다. 3. 그렇지 않으면 J를 인쇄합니다.
예를 들어, 4개의 문서(A, B, C, D)가 순서대로 인쇄 대기목록에 있고 중요도가 2 1 3 2 라면 C D A B 순으로 인쇄하게 됩니다.
내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 알고 싶습니다. 위의 예에서 C는 1번째로, A는 3번째로 인쇄됩니다.
현재 대기목록에 있는 문서의 중요도가 순서대로 담긴 배열 priorities와 내가 인쇄를 요청한 문서가 현재 대기목록의 어떤 위치에 있는지를 알려주는 location이 매개변수로 주어질 때, 내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 return 하도록 solution 함수를 작성해주세요.

제한사항

• 현재 대기목록에는 1개 이상 100개 이하의 문서가 있습니다.
• 인쇄 작업의 중요도는 1~9로 표현하며 숫자가 클수록 중요하다는 뜻입니다.
• location은 0 이상 (현재 대기목록에 있는 작업 수 - 1) 이하의 값을 가지며 대기목록의 가장 앞에 있으면 0, 두 번째에 있으면 1로 표현합니다.

입출력 예

내 문제풀이

1. 프린트 된 문서를 저장할 리스트(printer)를 생성한다.
2. 아무 문서도 프린트하지 않은 상태에서, 가장 중요도가 높은 문서를 먼저 프린트하여 초기화 작업을 한다.
   - 프린트 작업 : 해당 문서의 index를 printer에 저장하고, priorities에서 중요도는 임의의 최솟값(-1)로 수정
3. location이 printer에 있을 때(프린터 된 경우)까지 무한 루프를 돈다.
4. priorities의 index를 +1씩 증가시키며 중요도 최댓값과 일치하는지 비교한다. index가 (priorities길이-1)일 때까지만 +1을 한 후 넘어가는 경우 0으로 재설정하여 반복한다.
5. 중요도 최댓값과 일치하는 경우 위의 프린트 작업을 수행하고 answer+1을 해준다.

내 코드 - 파이썬 

def solution(priorities, location):
    answer = 1
    printer = [] # 프린트 된 문서 index 
    
    # 초기화 작업 : 중요도 가장 높은 문서의 index를 printer에 저장
    idx = priorities.index(max(priorities))
    printer.append(idx)
    # 대기목록에서는 중요도를 임의의 최소값(-1)으로 변경
    priorities[idx] = -1
    
    while(1):
        # 요청 문서 index가 프린트 된 경우
        if location in printer:
            return answer
        
        # 중요도 최댓값 계산
        top_pri = max(priorities)
        
        # index를 +1씩 추가하며 중요도 최댓값과 같으면 인쇄
        if idx+1 <= len(priorities)-1: idx += 1
        else: idx = 0            
        if priorities[idx] == top_pri:
            answer += 1
            printer.append(idx)
            priorities[idx] = -1
    
    return answer
   

문제 설명

트럭 여러 대가 강을 가로지르는 일 차선 다리를 정해진 순으로 건너려 합니다. 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다. 트럭은 1초에 1만큼 움직이며, 다리 길이는 bridge_length이고 다리는 무게 weight까지 견딥니다.
※ 트럭이 다리에 완전히 오르지 않은 경우, 이 트럭의 무게는 고려하지 않습니다.
예를 들어, 길이가 2이고 10kg 무게를 견디는 다리가 있습니다. 무게가 [7, 4, 5, 6]kg인 트럭이 순서대로 최단 시간 안에 다리를 건너려면 다음과 같이 건너야 합니다.

따라서, 모든 트럭이 다리를 지나려면 최소 8초가 걸립니다.
solution 함수의 매개변수로 다리 길이 bridge_length, 다리가 견딜 수 있는 무게 weight, 트럭별 무게 truck_weights가 주어집니다. 이때 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 return 하도록 solution 함수를 완성하세요.

제한 조건

• bridge_length는 1 이상 10,000 이하입니다.
• weight는 1 이상 10,000 이하입니다.
• truck_weights의 길이는 1 이상 10,000 이하입니다.
• 모든 트럭의 무게는 1 이상 weight 이하입니다.

입출력 예

내 문제풀이

1. 다리 위의 트럭을 표현하는 list(bridge)를 생성한다. 길이는 다리 길이, 값은 0으로 초기화를 해둔다.

2. bridge 길이가 0이 되기 전까지 반복문을 실행한다. 이 때 소요 시간(answer)과 다리 위 트럭의 합산 무게(weight_sum)를 계산한다. while문을 시작할 때마다 answer은 +1, weight_sum은 bridge의 가장 마지막 무게를 뺀다.

3. 대기 트럭이 있다면, weight_sum + 대기 트럭 중 가장 앞에 있는 트럭 무게와 다리가 견딜 수 있는 무게를 비교한다. 다리가 견딜 수 있는 무게가 더 크거나 같다면,
- weight_sum에 대기 트럭 중 가장 앞 트럭 무게를 더하고
- bridge에 해당 트럭을 추가한다.

4. 다리가 견딜 수 있는 무게가 더 작다면, bridge에 0을 추가한다. 아무런 트럭이 올라가지 못한 것으로 취급한다.

5. 다리 위 트럭이 모두 빠져나갈 때까지의 시간을 계산해야 하기 때문에 대기 트럭이 없더라도 계속해서 bridge의 값을 제거해야 한다. bridge가 모두 비어버리면 그 때 while문이 종료된다.

내 코드 - 파이썬

def solution(bridge_length, weight, truck_weights):
    answer = 0
    weight_sum = 0
    bridge = [0]*bridge_length
    
    while(len(bridge)):
        answer += 1
        weight_sum -= bridge.pop(0)
        
        if(len(truck_weights)):
            if(weight_sum + truck_weights[0] <= weight):
                    truck = truck_weights.pop(0)
                    bridge.append(truck)
                    weight_sum += truck
            else:
                bridge.append(0)
        
    return answer

문제 설명

프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.
또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다.
먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 하도록 solution 함수를 완성하세요.

제한 사항

• 작업의 개수(progresses, speeds배열의 길이)는 100개 이하입니다.
• 작업 진도는 100 미만의 자연수입니다.
• 작업 속도는 100 이하의 자연수입니다.
• 배포는 하루에 한 번만 할 수 있으며, 하루의 끝에 이루어진다고 가정합니다. 예를 들어 진도율이 95%인 작업의 개발 속도가 하루에 4%라면 배포는 2일 뒤에 이루어집니다.

입출력 예

내 문제풀이

1. 앞 작업부터 소요 시간을 저장해두고, 이를 기준으로 반복문을 통해 뒷 작업의 소요 시간과 비교한다. 가장 첫 작업에서는 반복문 수행 전에 초기화를 해두고, 반복문을 1~작업 길이까지 수행한다.
2. 저장한 소요 시간보다 뒷 작업 소요시간이 작거나 같으면 한 배치에 배포할 수 있는 작업 수(count)를 증가시킨다.
3. 저장한 소요 시간보다 뒷 작업 소요시간이 크면 이전까지 증가시킨 count 값을 answer에 저장하고 count와 작업 소요 시간을 다시 설정한다.
4. 반복문이 끝나면 마지막으로 계산했던 count를 answer에 저장한다.

내 코드 - 파이썬

from math import ceil

def solution(progresses, speeds):
    answer = []
    # old_date : 현재 작업까지 가장 긴 소요 시간
    # 첫번째 작업 기준으로 초기화
    old_date = ceil((100-progresses[0])/speeds[0])
    count = 1
    
    for idx in range(1, len(progresses)):
        # 현재 작업 소요시간이 old_date보다 작거나 같은 경우
        if ceil((100-progresses[idx])/speeds[idx]) <= old_date:
            count += 1
            continue
            
        # 현재 작업 소요시간이 old_date보다 큰 경우
        else:
            answer.append(count)
            count = 1
            # old_date 현재 작업 기준으로 다시 계산
            old_date = ceil((100-progresses[idx])/speeds[idx])
            
    # 마지막 작업에서 append를 못하므로 마지막 count를 추가
    answer.append(count)
    
    return answer

문제 설명

초 단위로 기록된 주식가격이 담긴 배열 prices가 매개변수로 주어질 때, 가격이 떨어지지 않은 기간은 몇 초인지를 return 하도록 solution 함수를 완성하세요.

제한사항

• prices의 각 가격은 1 이상 10,000 이하인 자연수입니다.
• prices의 길이는 2 이상 100,000 이하입니다.

입출력 예

내 문제풀이

1. prices길이 -1 만큼 반복문을 돌면서, 현재 주식 가격과 이후의 주식 가격들을 비교한다. 이 때 이중 for 문을 사용한다.
2. 현재 - 이후 주식 가격을 한 번 비교할 때마다 count를 1씩 증가시킨다.
3. 어떤 이후 주식 가격이 현재 주식 가격보다 낮아진 경우 반복문을 중단시키고 answer에 count(가격이 떨어지지 않은 초)를 저장한다.
4. 가장 마지막의 주식 가격은 항상 count(가격이 떨어지지 않은 초)가 0이므로 마지막에 answer에 0을 추가한다.

내 코드 - 파이썬

def solution(prices):
    answer = []
    
    for cur_idx in range(0, len(prices)-1):
        count = 0
        for next_idx in range(cur_idx+1, len(prices)):
            count +=1 
            if prices[cur_idx] > prices[next_idx]:
                break
        answer.append(count)
    answer.append(0)
    
    return answer