방구석프로의 이야기

https://school.programmers.co.kr/learn/courses/30/lessons/42842

문제 해결을 위한 과정

이 문제의 경우 수학적 지식을 이용하면 해결할 수 있는 문제였습니다.

저 같은 경우는 for문을 돌리면서 yellow의 가로길이는 brown-2라는 것을 이용해 해결할 수 있었습니다. 이를 소스코드로 작성하면 다음과 같습니다. 또한 가로, 세로의 순서를 맞추기 위해 가로에 더 큰 값을 집어넣어야 합니다. 이를 위해 answer.clear()를 넣어주어 혹시 모를 가로, 세로 길이의 역전을 방지하였습니다.

소스코드

def solution(brown, yellow):
    answer = []
    n = brown // 2
    for i in range(3, n):
        temp = yellow % (i-2)
        if temp == 0:
            temp2 = yellow // (i-2)
            if i + i + temp2 + temp2 == brown:
                answer.clear()
                answer.append(i)
                answer.append(temp2 + 2)
        
    return answer

https://school.programmers.co.kr/learn/courses/30/lessons/42839

문제 해결을 위한 과정

이 문제의 경우 permutaions를 이용하면 해결할 수 있는 문제였습니다. 순서가 중요하므로 조합이 아닌 순열이라는 점이 중요합니다.

결국 각각의 수로 만들 수 있는 순열을 생성한 뒤 해당 숫자가 소수인지를 판별하면 됩니다. 중복이 허용되지 않으므로 set자료형에 삽입하여 중복을 제거하였습니다. 

소수 판별의 경우 isPrime이라는 메소드를 생성하여 해결하였습니다. 소스코드로 작성하면 다음과 같습니다.

소스코드

from itertools import permutations
import math

def isPrime(num):
    if num <= 1:
        return False
    
    for i in range(2, int(math.sqrt(num)) + 1):
        if num % i == 0:
            return False
    return True

def solution(numbers):
    answer = 0
    tempAnswer = set()
    temp = []
    for i in range(len(numbers)):
        temp.append(numbers[i])
        
    for i in range(1, len(temp) + 1):
        for p in permutations(temp, i):
            tmp = ""
            for j in range(len(p)):
                tmp += p[j]
            if isPrime(int(tmp)):
                tempAnswer.add(int(tmp))
    answer = len(tempAnswer)
    return answer

https://school.programmers.co.kr/learn/courses/30/lessons/42587

문제 해결을 위한 과정

이 문제는 deque를 이용하면 쉽게 해결할 수 있는 문제였습니다. 과정은 다음과 같습니다.

1. priorities 배열을 조회하며 인덱스를 포함한 pair형태로 deque에 넣어준다.

2. 그 후 반복문으로 조회를 하면서 맨 앞에 원소와 인덱스 값을 꺼낸 뒤 다시 한번 for문으로 조회를 하며 deque내부에 더 높은 우선순위가 있는지 찾는다.

3. 더 높은 우선순위가 있다면 append로 뒤에 넣어준다.

4. 더 높은 우선순위가 없다면 처리한다.

4-1. 단 이때 처리된 인덱스가 location과 일치하는지 확인한다.

소스코드

from collections import deque

def solution(priorities, location):
    answer = 0
    q = deque()
    for i in range(len(priorities)):
        q.append((priorities[i], i))
    ans = 0
    
    while len(q) != 0:
        now, idx = q.popleft()
        flag = True
        for i in range(len(q)):
            next, nIdx = q[i]
            if next > now:
                q.append((now, idx))
                flag = False
                break
        if flag == True:
            ans += 1
            if idx == location:
                answer = ans
                break
            
    return answer

https://school.programmers.co.kr/learn/courses/30/lessons/42628

문제 해결을 위한 과정

이 문제는 heapq를 2개 만들어서 해결하면 쉽게 해결할 수 있는 문제였습니다.

파이썬의 경우 최소 힙 방식이므로 heapq에서 pop 하면 최솟값이 나온다는 것을 염두에 두면 다른 힙에는 원래 수에 -1을 곱한 값을 넣어서 최댓값을 꺼낼 수 있다는 것을 알 수 있습니다. 그림으로 표현하면 다음과 같습니다.

힙을 2개 만들어서 첫번째 힙에는 원래대로 숫자를 삽입, 두 번째 힙에는 -1을 곱한 수를 넣었습니다. 이렇게 하면 첫 번째 힙에서 pop 하면 최솟값을, 두 번째 힙에서는 pop한뒤 -1을 곱하면 최댓값을 pop 할 수 있게 됩니다.

소스코드

import heapq

def solution(operations):
    answer = []
    maxQ = []
    minQ = []
    for i in range(len(operations)):
        cmd, num = operations[i].split()
        num = int(num)
        if cmd == "I":
            heapq.heappush(maxQ, (num))
            heapq.heappush(minQ, (num*-1))
        elif cmd == "D":
            if num == -1 and len(maxQ) != 0:
                delNum = heapq.heappop(maxQ)
                for i in range(len(minQ)):
                    if minQ[i] == delNum*-1:
                        minQ.pop(i)
                        break
            elif num == 1 and len(maxQ) != 0:
                delNum = heapq.heappop(minQ)
                for i in range(len(maxQ)):
                    if maxQ[i] == delNum*-1:
                        maxQ.pop(i)
                        break
    if len(maxQ) == 0 and len(minQ) == 0:
        answer.append(0)
        answer.append(0)
    else:
        answer.append(heapq.heappop(minQ)*-1)
        answer.append(heapq.heappop(maxQ))
    return answer

https://school.programmers.co.kr/learn/courses/30/lessons/12909

문제 해결을 위한 과정

이 문제의 경우 괄호를 (, )로 분리하면 쉽게 해결할 수 있는 문제였습니다.

각각 (의 경우 1을 더하고, )인 경우 1을 빼주면 되는데 )부터 시작하면 올바르지 않은 괄호이고 결과는 음수, (()) 이렇게 올바른 경우는 1 + 1 - 1- 1이므로 결과는 0, ((()) 올바르지 않은 괄호는 1 + 1 + 1 - 1 - 1 이므로 양수 즉 올바르지 않은 경우입니다. 이를 문제에 적용하면 쉽게 해결할 수 있습니다.

소스코드

def solution(s):
    answer = True
    res = 0
    
    for i in range(len(s)):
        if s[i] == "(":
            res += 1
        else:
            res -= 1
        if res < 0:
            return False
    if res == 0:
        return True
    else:
        return False

https://school.programmers.co.kr/learn/courses/30/lessons/42627

문제 해결을 위한 과정

이 문제의 경우 heapq를 이용하면 해결할 수 있는 문제였습니다.

과정을 설명하면 다음과 같습니다.

1. jobs 리스트 정렬

2. 맨 처음 인덱스에 해당하는 값을 이용해 finish, answer 할당(finish는 작업이 끝나는 시간, answer는 대기 시간)

3. 다시 jobs 리스트를 정렬하며 finish 보다 request가 이전인 경우(작업 중에 들어온 요청인 경우) heapq에 삽입

4. heapq가 존재하면 가장 짧은 duration을 가진 작업을 이용해서 finish, answer 재할당

5. heapq가 존재하지 않으면 jobs리스트를 정렬하며 맨 처음 인덱스에 해당하는 값을 이용해 finish, answer 할당

이 부분에서 8번 18번 테스트 케이스를 틀렸었는데 이는 동일 request에 여러 작업이 들어올 수 있기 때문입니다. 따라서 jobs 리스트를 정렬 시 lambda를 이용해서 request기준으로 오름차순을 하고, 만약 request가 같다면 duration으로도 오름차순 정렬을 해주면 됩니다.

소스코드

import heapq

def solution(jobs):
    answer = 0
    length = len(jobs)
    length2 = len(jobs)
    jobs.sort(key = lambda x: (x[0], x[1]))
    finish = 0
    finish = jobs[0][1] + jobs[0][0]
    answer += jobs[0][1]
    jobs.pop(0)
    length2 -= 1
    
    while length2 != 0:
        jobs.sort(key = lambda x: (x[0], x[1])) 
        q = []
        for i in range(len(jobs)):
            request, time = jobs[i]
            if request <= finish:
                heapq.heappush(q, (time, request, i))
        if len(q) != 0:
            time, request, idx = heapq.heappop(q)
            if request <= finish: # 하드디스크 작업 수행 중 들어온 요청인 경우
                finish = finish + time
                answer += finish - request
                length2 -= 1
                jobs.pop(idx)
            else:
                heapq.heappush(q, (time, request, idx)) # 하드디스크가 작업 수행을 하지 않는 경우   
        else:
            jobs.sort(key = lambda x: (x[0], x[1])) 
            request, time = jobs[0] # 가장 앞에 작업 수행
            finish = request + time
            answer += finish - request
            jobs.pop(0)
            length2 -= 1
    answer = answer // length
    
    return answer

https://school.programmers.co.kr/learn/courses/30/lessons/42583

문제 해결을 위한 과정

이 문제의 경우 deque를 이용하면 쉽게 해결할 수 있는 문제였습니다.

과정은 다음과 같습니다.

1. 다리에 존재하는 트럭들 한 칸 이동시키기 - queue를 (truck, cnt)로 pair 형태로 넣어두면 cnt를 1 증가시키는 걸로 가능

2. 1의 과정 이 후 제일 앞에 있는 트럭의 cnt가 bridge_length와 같다면 popleft 해주기. (다리를 다 이동한 경우)

3. 다리에 존재하는 트럭들의 무게를 확인하여 남은 트럭 중 제일 앞에 트럭을 올려도 올라가는지 확인

    3-1. 올라갈 수 있다면 다리에 올리기

    3-2. 올라갈 수 없다면 다리에 올리지 않기

소스코드

from collections import deque

def solution(bridge_length, weight, truck_weights):
    answer = 0
    finish = deque()
    moving = deque()
    length = len(truck_weights)
    
    while True:
        if len(finish) == length:
            break
        answer += 1
        for i in range(len(moving)): # 이동
            truck, cnt = moving[i]
            moving[i] = truck, cnt + 1           
        if len(moving) != 0:
            truck, cnt = moving[0] 
            if cnt == bridge_length: # 다리 다 이동하면 finish로 이동
                finish.append(moving.popleft())
        tempWeight = 0
        for i in range(len(moving)):
            truck, cnt = moving[i]
            tempWeight += truck
        if len(truck_weights) != 0 and tempWeight + truck_weights[0] <= weight:
            moving.append((truck_weights[0], 0))
            truck_weights.pop(0)
    return answer

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

문제해결을 위한 과정

이 문제는 각 배열을 조회하면서 해당하는 speeds를 더해주면 됩니다. 그 후 100이 넘는지 확인한 뒤(작업 완료) 완료된 작업만큼을 꺼내주면 되는 문제입니다. 단 이때 해당하는 인덱스의 speeds도 꺼내줘야 합니다. 소스코드는 다음과 같습니다.

소스코드

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