Frontend-Deep-Dive

[프로그래머스] 카펫 / 완전 탐색(Brute-force Search)

glowing713 — Thu, 18 Mar 2021 00:35:49 +0900

이미지를 클릭하면 문제 사이트로 이동합니다.

문제 이해

갈색 타일의 개수와 노란색 타일의 개수가 입력으로 주어질 때, 전체 카펫의 가로 길이와 세로 길이를 구하는 문제이다.

수식으로 정리해본다면,

1. 가로를 테두리를 포함해서 \(x+2\) 로 표현하고, 세로는 테두리를 포함하여 \(y+2\) 로 표현한다.

2. 위 수식을 기준으로 전체 칸 수는 \((x+2)(y+2) = brown + yellow\) 로 표현할 수 있다.

3. 노란 부분은 \(xy = yellow\) 로 표현할 수 있다.

4. 전체 칸 수를 나타내는 수식을 전개하면 \(xy+2x+2y+4=brown+xy\) 가 되고, 이를 정리하면 \(x+y = \frac{brown-4}{2}\) 라는 관계가 성립된다.

즉,

\(y = \frac{brown-4}{2}-x\) 관계를 만족하며 x의 변화에 따른 y 값을 구하다가

\(xy = yellow\) 조건이 만족하는 부분을 찾아내면 해답이 된다.

이 과정을 코드로 구현하면 다음과 같다.

구현 언어: Python

def solution(brown, yellow):
    answer = []
    x = 0
    y = brown
    while True:
        x += 1
        y = (brown - 4) // 2 - x
        if x * y == yellow:
            answer.append(y+2)
            answer.append(x+2)
            break
    return answer

[프로그래머스] 소수 찾기 / 완전 탐색(Brute-force Search)

glowing713 — Wed, 17 Mar 2021 17:07:00 +0900

이미지를 클릭하면 문제 사이트로 이동합니다.

문제 이해

한 자리의 숫자들이 나열된 문자열을 조합해서 만들 수 있는 소수의 갯수를 구하는 문제이다.

파이썬의 기본 모듈인 itertools.permutations를 이용하여 모든 경우를 구하고,

소수 판별은 숫자 범위가 0~9로 적으므로 2~n-1까지 나눠보면서 직접 찾아냈다.

구현 언어: Python

from itertools import permutations

# 소수 판별 함수
def is_prime_number(num: int) -> bool:
    if num < 2:
        return False
    for i in range(2, num):
        if num % i == 0:
            return False
    return True


def solution(numbers):
    answer = set()  # 중복되지 않는 모든 경우를 저장할 set
    for i in range(1, len(numbers)+1):
        num_list = list(''.join(tup) for tup in permutations(numbers, i))
        for num in num_list:
            if is_prime_number(int(num)):
                answer.add(int(num))
    return len(answer)

[프로그래머스] 다리를 지나는 트럭 / 큐(Queue)

glowing713 — Fri, 12 Mar 2021 16:50:22 +0900

이미지를 클릭하면 문제 사이트로 이동합니다.

문제 이해

트럭이 순서대로 대기하고 있고,

다리가 견딜 수 있는 무게 내에서 최대한 빠르게 모든 트럭이 통과하는 시간을 구하는 문제이다.

트럭들이 대기하다가 순서대로 지나가고, 다리 또한 한 방향으로 지나가기 때문에 Queue가 떠올랐다.

트럭이 지나가는 다리를 bridge라는 이름으로 queue(deque 사용)를 선언하고

대기 중인 트럭들을 waiting이라는 이름으로 queue를 선언했다.

대략적인 코드 구조는 다음과 같다.

0. 0초부터 1초 씩 증가하며 시간을 기록한다.

1. bridge가 비어있지 않다면 지금 시점에 지나가야하는 트럭은 dequeue 시킨다. (다리를 빠져나간다.)

2. bridge와 waiting에 남은 트럭이 없다면 현재 시간을 리턴함으로 반복문을 종료시킨다. (모든 차량을 처리한 경우)

3. 대기중인 차량이 존재한다면 다리의 총 무게를 체크해보고 현재 시점 기록과 함께 bridge에 진입시킨다.

(tuple(무게, 시간)을 bridge에 enqueue 시키는 것)

구현 언어: Python

from collections import deque


def solution(bridge_length, weight, truck_weights):
    time = 0
    weight_sum = 0
    bridge, waiting = deque(), deque(truck_weights)
    
    while True:
        time += 1
        # 체크하면서 이번 타임에 나가야할 트럭을 내보낸다.
        if bridge:  # 다리가 비어있지 않은 상태일 때
            if time == bridge[0][1] + bridge_length:
                weight_sum -= bridge[0][0]
                bridge.popleft()
        # 모든 차를 처리했다면 종료
        if (not bridge) and (not waiting):
            return time
        # 다리가 견딜 수 있는 무게에 한하여 추가할 차량을 추가한다.
        if waiting:
            if weight_sum + waiting[0] <= weight:
                bridge.append((waiting[0], time))  # 현재 시점 기록과 함께 다리에 진입
                weight_sum += waiting[0]  # 다리의 총 무게 갱신
                waiting.popleft()  # 대기열에서 제거
    return time

[프로그래머스] 가장 큰 수 / 정렬

glowing713 — Thu, 11 Mar 2021 18:08:46 +0900

이미지를 클릭하면 문제 사이트로 이동합니다.

문제 이해

정수를 붙였을 때 가장 큰 수가 되도록 만들어주어야 한다.

모든 조합을 구해서 최대값을 팩토리얼 연산으로 구한다면, 여기서 유의할 점은 최대 10만 개의 입력이 들어올 수 있다는 점이다.

그렇다면 먼저 조건에 맞게 정렬을 해주고 Join 하는 방법도 있다.

서로 다른 자리의 숫자를 합쳤을 때 최대가 되도록 하기 위해서, 문자열 대소비교의 특징을 사용했다.

문자열은 대소비교를 할 때, 첫 자리가 큰 수를 찾아내고 숫자가 같다면 길이가 긴 것을 큰 것으로 인정한다.

숫자는 최대 1000 까지 가능하므로

각 숫자를 문자열로 바꾸어주고 3배로 연장하여 대소비교를 수행하면 조건에 맞게 정렬할 수 있게 된다.

구현 언어: Python

def solution(numbers):
    # 문자열은 첫 글자부터 비교한다는 점이 포인트!!
    sorted_nums = sorted(list(map(str, numbers)), key=lambda x: x * 3, reverse=True)
    if sorted_nums[0][0] == '0':
        return '0'
    else:
        return ''.join(sorted_nums)

추가로 주의할 점은 입력이 [0, 0, 0, 0] 과 같은 경우, 결과 값이 '0000'이 된다.

이는 정상적인 숫자가 아니다.

이 경우를 처리하기 위해 주어진 입력의 최대 값인 0 번째 원소가 0이라면 '0'을 리턴하게 된다.

[프로그래머스] 도둑질 / 동적 계획법(Dynamic-Programming)

glowing713 — Thu, 11 Mar 2021 16:43:37 +0900

이미지를 클릭하면 문제 사이트로 이동합니다.

문제 이해

두 수를 인접하지 않게 선택하여 최대 합을 구하는 문제이다.

마을이 원형구조이므로 1, 2, 3, 4번 집이 있을 때,

1번은 2번, 4번과 인접해있다.

따라서 1번을 선택할 때의 경우(2, 4번은 선택불가)와 1번을 선택하지 않을 경우(1번만 사용불가)를 나누어서

두 결과값 중 최대를 반환하면 된다.

구현 언어: Python

def solution(money):
    # 3 1 4 7 2 5
    case1 = [i for i in money]
    case2 = [i for i in money]
    # 첫 번째를 선택하는 경우
    case1[1], case1[-1] = case1[0], 0
    # 첫 번째를 선택하지 않는 경우
    case2[0] = 0
    
    for i in range(2, len(money)):
        case1[i] = max(case1[i-1], case1[i-2] + case1[i])
        case2[i] = max(case2[i-1], case2[i-2] + case2[i])
    
    # print(f'case1: {case1}')
    # print(f'case2: {case2}')
    
    return max(case1[-1], case2[-1])

여기서, 제출했을 때 계속해서 1번 케이스만 틀리는 문제가 발생했다.

커뮤니티에 다른 분들이 올려주신 댓글을 확인해보니 나는 이전(i-1)과 그 이전(i-2)를 체크하는데,

10 0 0 1000 10 2 와 같은 경우 올바른 결과를 찾아내지 못하는 걸 발견했다.

위 예제에서 10를 선택하는 경우, 두 번째인 0과 마지막인 2를 0으로 초기화했었는데

두 번째 값인 0을 첫 번째와 같은 값인 10으로 만들어서 첫 번째 값의 손실을 해결할 수 있었다.

[프로그래머스] 등굣길 / 동적 계획법(Dynamic-Programming)

glowing713 — Thu, 11 Mar 2021 16:28:57 +0900

이미지를 클릭하면 문제 사이트로 이동합니다.

문제 이해

격자를 오른쪽과 아래쪽으로 이동하며 최단 경로의 수를 측정하는 문제이다.

DP로 풀 수 있고, 물이 있는 부분을 어떻게 체크하느냐가 포인트인 문제이다.

구현 언어: Python

def solution(m, n, puddles):
    maps = [[0]*(m+1) for _ in range(n+1)]
    dp = [[0]*(m+1) for _ in range(n+1)]
    # 물 체크
    for pud in puddles:
        maps[pud[1]][pud[0]] = -1
        
    dp[1][0] = 1  # 시작지점은 1
    for i in range(1, n+1):
        for j in range(1, m+1):
            if maps[i][j] == -1:
                dp[i][j] = 0
            else:
                dp[i][j] = (dp[i-1][j] + dp[i][j-1]) % 1000000007
    return dp[n][m]

maps는 현재 지도의 상태를 나타내는 배열로서, 물이 있는 위치라면 그 곳을 -1로 기록해둔다.

dp는 이동 경로를 기록하는 배열로서, 물이 있는 위치라면 그 곳은 0이 된다. (이동할 수 없다는 뜻)

0	0	0	0
1
	0

예제에 주어진 경로의 상태이다.

0행과 0열은 이동할 수 없는 공간으로서 0으로 채워지게 되고, 물로 채워진 공간 또한 0이 된다.

0	0	0	0
1	1	1	1
1	0	1	2
1	1	2	4

(1, 1) 위치부터 주어진 귀납식에 따라 채워나가면 최종 목적지인 (n, m)에 최단경로의 수를 찾을 수 있게 된다.

[BOJ] 백준 1535 안녕 / 동적 계획법(Dynamic-Programming)

glowing713 — Thu, 11 Mar 2021 16:09:36 +0900

이미지를 클릭하면 문제 사이트로 이동합니다.

문제 이해

세준이 체력이 최대 100이므로 숫자를 증가시키면서 해당 체력내에 얻을 수 있는 최대 기쁨을 갱신한다.

구현 언어: Python

import sys

r = sys.stdin.readline

n = int(r())
hp_loss = list(map(int, r().split()))
pleasure = list(map(int, r().split()))
dp = [[0]*101 for _ in range(n+1)]

for i in range(1, n+1):
    for j in range(100):
        if j < hp_loss[i-1]:
            dp[i][j] = dp[i-1][j]
        else:
            dp[i][j] = max(dp[i-1][j], dp[i-1][j-hp_loss[i-1]] + pleasure[i-1])

print(dp[n][99])

[BOJ] 백준 2512 예산 / 이분탐색

glowing713 — Thu, 11 Feb 2021 23:53:43 +0900

이미지를 클릭하면 문제 사이트로 이동합니다.

문제 이해

국가예산이 주어지고, N개의 지방에서 예산 요청이 주어질 때 정해진 예산 내에서 최대 얼마까지 배정할 수 있는 지 계산하는 문제이다.

내용은 다르지만 큰 틀은 이전에 풀었던 이분탐색 문제들과 다를 바가 없다.

최소 예산인 1부터 최대 예산인 max(지방의 예산요청들) 사이에서 이분탐색을 하며 그 값을 찾아내면 된다.

구현 언어: Python

import sys

r = sys.stdin.readline

def binary_search(requests: list, budget: int) -> int:
    result = 0
    left = 1
    right = max(requests)
    while left <= right:
        mid = (left + right) // 2
        total_sum = sum(mid if req >= mid else req for req in requests)
        if total_sum <= budget:
            result = mid
            left = mid + 1
        else:
            right = mid - 1
    return result

_, bud_requests, total_bud = r(), list(map(int, r().split())), int(r())
print(binary_search(bud_requests, total_bud))

이러한 양식의 다른 문제들에서

현재 설정한 최대 상한액(mid) 기준으로 배정할 수 있는 예산액을 계산하는 total_sum 부분의 연산을 줄이기 위해서

Counter를 사용해 같은 값이 여러 개 존재하면 value*key 와 같은 방식으로 처리하곤 했다.

그러나 이 문제에서 예산 요청이 최대 10,000 개이다.

import sys
from collections import Counter

r = sys.stdin.readline

def binary_search(requests: Counter, budget: int) -> int:
    result = 0
    left = 1
    right = max(requests)
    while left <= right:
        mid = (left + right) // 2
        total_sum = sum(mid*cnt if req >= mid else req*cnt for req, cnt in requests.items())
        if total_sum <= budget:
            result = mid
            left = mid + 1
        else:
            right = mid - 1
    return result

_, bud_requests, total_bud = r(), Counter(map(int, r().split())), int(r())
print(binary_search(bud_requests, total_bud))

위 결과를 통해 확인할 수 있는 것처럼 처리할 값의 수가 많지 않다면 오히려 Counter를 쓰는 것이 시간 효율 측면에서 떨어지는 것을 확인할 수 있었다.(위가 Counter, 아래가 일반적인 방법)

데이터의 수가 많다면 Counter를 사용하는 것이 실행 시간을 줄이기 위한 좋은 시도이나,

데이터의 수가 적다면 일반적인 방법으로 계산하는 것이 오히려 좋다..!

[BOJ] 백준 1764 듣보잡 / 이분탐색

glowing713 — Thu, 11 Feb 2021 17:22:35 +0900

이미지를 클릭하면 문제 사이트로 이동합니다.

문제 이해

제목이....ㅋ

암튼 전형적인 방법으로 풀면 이분탐색이지만,

파이썬의 장점을 잘 살리면 이분탐색보다 실행속도도 더 빠르고 간단하게 풀어낼 수 있다.

풀이 방법은 다음과 같다.

1. 이분탐색

2. Set 자료구조와 in 연산자

3. Set의 교집합을 구할 수 있는 & 연산자

4. Set과 intersection 메소드를 이용한 교집합 연산

실행속도는 4 > 3 >= 2 > 1 순으로 빠르다.

구현 언어: Python

1. 이분탐색

import sys

r = sys.stdin.readline

def binary_search(d_list: list, b_list: list) -> list:
    result = []
    d_list.sort()
    for b in b_list:
        left = 0
        right = len(d_list) - 1
        while left <= right:
            mid = (left + right) // 2
            if d_list[mid] < b:
                left = mid + 1
            elif d_list[mid] > b:
                right = mid - 1
            else:
                result.append(b)  # 듣도 보도 못한 명단 찾음
                break  # 여기서 꼭 종료를 해주어야 한다!
    return sorted(result)

d_num, b_num = map(int, r().split())
d_list = list(r().rstrip() for _ in range(d_num))  # 듣도 못한 명단
b_list = list(r().rstrip() for _ in range(b_num))  # 보도 못한 명단
answer = binary_search(d_list, b_list)  # 사전순으로 정렬된 듣도 보도 못한 명단
print(len(answer))
for name in answer:
    print(name)

2. Set 자료구조와 in 연산자

import sys

r = sys.stdin.readline

d_num, b_num = map(int, r().split())
d_list = set(r().rstrip() for _ in range(d_num))  # 듣도 못한 명단
b_list = list(r().rstrip() for _ in range(b_num))  # 보도 못한 명단
answer = sorted([name for name in b_list if name in d_list])
print(len(answer))
for name in answer:
    print(name)

Set은 Hash function으로 구현이 되어있어서 Dict를 사용할 때처럼 in 연산자를 O(1)의 시간으로 사용할 수 있어 매우 빠르다!

3. Set의 교집합을 구할 수 있는 & 연산자

import sys

r = sys.stdin.readline

d_num, b_num = map(int, r().split())
d_list = set(r().rstrip() for _ in range(d_num))  # 듣도 못한 명단
b_list = set(r().rstrip() for _ in range(b_num))  # 보도 못한 명단
answer = sorted(d_list & b_list)
print(len(answer))
for name in answer:
    print(name)

4. Set과 intersection 메소드를 이용한 교집합 연산

import sys

r = sys.stdin.readline

d_num, b_num = map(int, r().split())
d_list = set(r().rstrip() for _ in range(d_num))  # 듣도 못한 명단
b_list = set(r().rstrip() for _ in range(b_num))  # 보도 못한 명단
answer = sorted(d_list.intersection(b_list))  # 내장 메소드가 더 빠름!!
print(len(answer))
for name in answer:
    print(name)

[BOJ] 백준 10816 숫자 카드 2 / 이분탐색

glowing713 — Tue, 9 Feb 2021 23:56:09 +0900

이미지를 클릭하면 문제 사이트로 이동합니다.

문제 이해

이전에 풀었던 숫자 카드 문제와 거의 비슷하다.

주어진 숫자 입력들이 상근이가 가진 숫자 카드에 있는지 여부를 체크하는 문제였다면,

이 문제는 상근이가 그 숫자들을 몇 개 가지고 있는 지도 체크해야 한다는 점이다.

Python의 Counter를 이용해서 상근이의 숫자 카드를 Key 값으로 카드번호, Value 를 카드 개수로 하는 딕셔너리를 생성했다.

그리고 입력으로 들어온 숫자가 Counter 객체에 존재한다면 Value를 출력하고, 없다면 0을 출력하게 구현했다.

구현 언어: Python

import sys
from collections import Counter

r = sys.stdin.readline

answer = []
n, my_card = int(r()), Counter(map(int, r().split()))
m, num_list = int(r()), list(map(int, r().split()))

for num in num_list:
    answer.append(my_card[num] if num in my_card.keys() else 0)
print(*answer)

여기서 더 Pythonic 하고 싶다면,

import sys
from collections import Counter
r = sys.stdin.readline

_, my_card, _ = r(), Counter(r().split()), r()
print(" ".join(str(my_card[num]) if num in my_card else '0' for num in r().split()))

요런 것도 가능하다