Merge branch 'chaeshee0908'

_posts/algorithm/4와-7/2023-10-29-채승희-4와-7.md

@@ -0,0 +1,57 @@
+---
+title: 🐹 4와 7
+author: chaeshee0908
+date: 2023-10-29 20:00:00 +09:00
+categories: [알고리즘, 4와 7]
+tags: [알고리즘, 백준, 골드5, 구현, 5주차, 채승희]
+render_with_liquid: false
+---
+
+## 1. 문제 링크
+
+[2877번: 4와 7](https://www.acmicpc.net/problem/2877)
+
+<br>
+
+## 2. 코드
+
+`Python3` `31120kb` `40ms`
+
+```python
+count = [2**i for i in range(31)]
+K = int(input())
+
+num = 0
+for i in range(1, 31):
+    num += count[i]
+    if K <= num:
+        num_len = i  # K번째 숫자의 길이
+        break
+
+k_location = K - (num - count[num_len])
+result = ''
+
+div_num = 2
+while num_len:
+    n = k_location % div_num
+    if n == 0 or n > (div_num // 2):
+        result = '7' + result
+    else:
+        result = '4' + result
+    num_len -= 1
+    div_num *= 2
+
+print(int(result))
+```
+
+<br>
+
+## 3. 해설
+
+먼저 K번째 숫자의 길이를 파악해줍니다. 여기서는 `num_len`
+
+가장 작은 자리수 부터 값을 구해줍니다. 각 자리에는 4와 7만 들어갈 수 있으므로 경우의 수는 2의 `num_len` 제곱배 입니다.
+
+확인하는 자리가 한 칸 앞으로 갈 때마다 `div_num`(나누어주는 수)에 2를 곱해줍니다. 이때 div_num으로 나눈 나머지가 `div_num`의 2분의 1배보다 작다면 ‘4’, 크다면(혹은 0으로 나누어 떨어진다면) ‘7’을 값에 연결해줍니다.
+
+K번째 숫자의 길이만큼 반복해주고 문자열로 다뤘던 값을 int형으로 형변환 해줍니다.

_posts/algorithm/거리두기-확인하기/2023-12-03-채승희-거리두기-확인하기.md

@@ -0,0 +1,106 @@
+---
+title: 🐹 거리두기 확인하기
+author: chaeshee0908
+date: 2023-12-03 20:00:00 +09:00
+categories: [알고리즘, 거리두기 확인하기]
+tags: [알고리즘, 프로그래머스, level2, 구현, 7주차, 채승희]
+render_with_liquid: false
+---
+
+## 1. 문제 링크
+
+[거리두기 확인하기](https://school.programmers.co.kr/learn/courses/30/lessons/81302)
+
+<br>
+
+## 2. 코드
+
+```python
+def solution(places):
+    answer = []
+    for place in places:
+        candidate = find_candidate(place)
+        answer.append(check_observe_distance(place, candidate))
+    return answer
+
+def find_candidate(place):
+    candidate = []
+    for i in range(5):
+        for j in range(5):
+            if place[i][j] == 'P':
+                candidate.append((i, j))
+    return candidate
+
+def check_observe_distance(place, candidate):
+    for i in range(len(candidate)-1):
+        now_x, now_y = candidate[i]
+        for j in range(i+1, len(candidate)):
+            if i == j:
+                continue
+            next_x, next_y = candidate[j]
+            manhattan = abs(now_x - next_x) + abs(now_y - next_y)
+            diff_x, diff_y = abs(now_x - next_x), abs(now_y - next_y)
+            # 맨허튼 거리가 1이하인 경우
+            if manhattan <= 1:
+                return 0
+            # 맨허튼 거리가 2인 경우
+            if manhattan == 2:
+                # 가로 길이 2인 경우 중 파티션 없는 경우
+                if diff_x == 2 and place[min(now_x, next_x)+1][now_y] != 'X':
+                    return 0
+                # 세로 길이 2인 경우 중 파티션 없는 경우
+                elif diff_y == 2 and place[now_x][min(now_y, next_y)+1] != 'X':
+                    return 0
+                # 대각선인 경우 중 파티션 없는 경우
+                elif place[now_x][next_y] == 'O' or place[next_x][now_y] == 'O':
+                    return 0
+    return 1
+```
+- 실행 결과
+
+| 테스트 1 〉 | 통과 (0.16ms, 10.4MB) |
+| 테스트 2 〉 | 통과 (0.05ms, 10.3MB) |
+| 테스트 3 〉 | 통과 (0.04ms, 10.3MB) |
+| 테스트 4 〉 | 통과 (0.06ms, 10.2MB) |
+| 테스트 5 〉 | 통과 (0.04ms, 10.4MB) |
+| 테스트 6 〉 | 통과 (0.03ms, 10.2MB) |
+| 테스트 7 〉 | 통과 (0.03ms, 10.3MB) |
+| 테스트 8 〉 | 통과 (0.08ms, 10.4MB) |
+| 테스트 9 〉 | 통과 (0.04ms, 10.3MB) |
+| 테스트 10 〉 | 통과 (0.03ms, 10.2MB) |
+| 테스트 11 〉 | 통과 (0.04ms, 10.2MB) |
+| 테스트 12 〉 | 통과 (0.03ms, 10.4MB) |
+| 테스트 13 〉 | 통과 (0.04ms, 10.2MB) |
+| 테스트 14 〉 | 통과 (0.03ms, 10.4MB) |
+| 테스트 15 〉 | 통과 (0.03ms, 10.3MB) |
+| 테스트 16 〉 | 통과 (0.06ms, 10.2MB) |
+| 테스트 17 〉 | 통과 (0.05ms, 10.2MB) |
+| 테스트 18 〉 | 통과 (0.06ms, 10.3MB) |
+| 테스트 19 〉 | 통과 (0.07ms, 10.2MB) |
+| 테스트 20 〉 | 통과 (0.08ms, 10.1MB) |
+| 테스트 21 〉 | 통과 (0.07ms, 10.2MB) |
+| 테스트 22 〉 | 통과 (0.06ms, 10.4MB) |
+| 테스트 23 〉 | 통과 (0.02ms, 10.3MB) |
+| 테스트 24 〉 | 통과 (0.03ms, 10.3MB) |
+| 테스트 25 〉 | 통과 (0.03ms, 10.4MB) |
+| 테스트 26 〉 | 통과 (0.02ms, 10.1MB) |
+| 테스트 27 〉 | 통과 (0.03ms, 10.3MB) |
+| 테스트 28 〉 | 통과 (0.03ms, 10.2MB) |
+| 테스트 29 〉 | 통과 (0.05ms, 10.4MB) |
+| 테스트 30 〉 | 통과 (0.03ms, 10.4MB) |
+| 테스트 31 〉 | 통과 (0.05ms, 10.4MB) |
+
+<br>
+
+## 3. 해설
+
+강의실 별 응시자들의 위치 정보를 담은 candidate를 생성한 후, 강의실 별 가능한 경우를 파악한다. 
+
+불가능한 경우는 다음과 같다.
+
+1. 맨허튼 거리 = 1
+2. 맨허튼 거리 = 2
+    1. 가로 거리 혹은 세로 거리가 2차이 일때 가운데 위치에 파티션이 없는 경우
+    2. 대각선에 응시자들이 위치할 때 반대 방향 대각선 중 파티션이 하나라도 없는 경우
+
+candidate 위치를 비교하여 위의 불가능한 경우일 때는 0을 리턴, 그 이외는 1을 리턴하는 check_observe_distance 함수를 작성한 후 answer에 값을 넣어준다.

_posts/algorithm/미로-탈출-명령어/2023-12-03-채승희-미로-탈출-명령어.md

@@ -0,0 +1,110 @@
+---
+title: 🐹 미로 탈출 명렁어
+author: chaeshee0908
+date: 2023-12-03 20:00:00 +09:00
+categories: [알고리즘, 미로 탈출 명렁어]
+tags: [알고리즘, 프로그래머스, level3, 구현, 7주차, 채승희]
+render_with_liquid: false
+---
+
+## 1. 문제 링크
+
+[미로 탈출 명렁어](https://school.programmers.co.kr/learn/courses/30/lessons/150365)
+
+<br>
+
+## 2. 코드
+
+```python
+dx = [1, 0, 0, -1]
+dy = [0, -1, 1, 0]
+move = ['d', 'l', 'r', 'u']
+
+from collections import deque
+import sys
+
+def solution(n, m, x, y, r, c, k):
+    sys.setrecursionlimit(5000)
+    q = deque([])
+    q.append((x, y, 0, ''))
+    # 최단 거리 길이
+    min_dist = abs(x-r) + abs(y-c)
+
+    # 최단 거리보다 이동 가능 거리가 작거나 도달이 불가능한 위치일 때 
+    if min_dist > k or (k - min_dist) % 2 == 1:
+        return 'impossible'
+
+    def find_path(a, b, count, path):
+        # k번으로 도달할 수 없는 경우 
+        if a == r and b == c and (k-count) % 2 == 1:
+            return 'impossible'
+        # k번째 도달
+        if a == r and b == c and count == k:
+            return path
+        for i in range(4):
+            na = a + dx[i]
+            nb = b + dy[i]
+            if 0 < na <= n and 0 < nb <= m:
+                # 이동 위치가 최종 위치에 도달할 수 없을만큼 멀어질 때 
+                if abs(na-r) + abs(nb-c) > k - (count+1):
+                    continue
+                result = find_path(na, nb, count+1, path + move[i])
+                return result
+
+    return find_path(x, y, 0, '')
+```
+
+- 정확성
+
+| 테스트 1 〉 | 통과 (0.21ms, 10.4MB) |
+| 테스트 2 〉 | 통과 (0.15ms, 10.4MB) |
+| 테스트 3 〉 | 통과 (0.01ms, 10.4MB) |
+| 테스트 4 〉 | 통과 (0.03ms, 10.3MB) |
+| 테스트 5 〉 | 통과 (0.04ms, 10.4MB) |
+| 테스트 6 〉 | 통과 (0.02ms, 10.4MB) |
+| 테스트 7 〉 | 통과 (0.02ms, 10.3MB) |
+| 테스트 8 〉 | 통과 (0.03ms, 10.3MB) |
+| 테스트 9 〉 | 통과 (10.15ms, 16MB) |
+| 테스트 10 〉 | 통과 (7.63ms, 16.1MB) |
+| 테스트 11 〉 | 통과 (9.03ms, 16.1MB) |
+| 테스트 12 〉 | 통과 (6.72ms, 16MB) |
+| 테스트 13 〉 | 통과 (7.26ms, 16.1MB) |
+| 테스트 14 〉 | 통과 (8.84ms, 16MB) |
+| 테스트 15 〉 | 통과 (6.66ms, 16.2MB) |
+| 테스트 16 〉 | 통과 (6.79ms, 15.7MB) |
+| 테스트 17 〉 | 통과 (6.54ms, 15.9MB) |
+| 테스트 18 〉 | 통과 (8.29ms, 15.9MB) |
+| 테스트 19 〉 | 통과 (6.31ms, 16.2MB) |
+| 테스트 20 〉 | 통과 (9.90ms, 15.8MB) |
+| 테스트 21 〉 | 통과 (8.67ms, 15.8MB) |
+| 테스트 22 〉 | 통과 (8.65ms, 15.8MB) |
+| 테스트 23 〉 | 통과 (13.91ms, 16.1MB) |
+| 테스트 24 〉 | 통과 (9.83ms, 16.1MB) |
+| 테스트 25 〉 | 통과 (6.76ms, 15.8MB) |
+| 테스트 26 〉 | 통과 (9.31ms, 15.8MB) |
+| 테스트 27 〉 | 통과 (9.86ms, 16MB) |
+| 테스트 28 〉 | 통과 (9.50ms, 15.8MB) |
+| 테스트 29 〉 | 통과 (9.52ms, 16MB) |
+| 테스트 30 〉 | 통과 (9.42ms, 16MB) |
+| 테스트 31 〉 | 통과 (0.01ms, 10.3MB) |
+
+<br>
+
+## 3. 해설
+
+이 문제는 불가능한 경우를 잘 걸러내주어 시간을 줄이는 것이 중요하다. 
+
+불가능한 경우는 다음과 같다.
+
+1. (x, y) → (r, c)의 최단 경로보다 k(이동 가능 거리)가 작을 때
+2. k(이동 가능 거리)에서 (x, y) → (r, c)의 최단 경로 길이를 뺀 길이가 2의 배수가 아닐 때
+
+    → 최단 거리 이동 후 좌,우 혹은 위,아래로 움직여 같은 자리로 돌아올 수 있어야한다. 
+
+3. 이동중의 위치에서 최종 위치까지의 거리를 남은 움직임으로 갈 수 없을 때 
+
+이때 사전순으로 결과를 찾아야하기 때문에 d(아래), l(왼쪽), r(오른쪽), u(위쪽) 순으로 움직이도록 나열하고 가장 첫 결과를 리턴한다. 
+
+처음에는 bfs로 큐를 사용하여 코드를 작성했지만, bfs를 사용하면 최종 목적지로 바로가지않고 주변을 모두 확인하고 최종 목적지로 가기 때문에 시간 초과가 났다. 
+
+dfs를 사용하여 최종 목적지까지 바로 갈 수 있도록 코드를 재구현했다. 이때 setrecursionlimit을 하지 않으면 런타임 에러가 뜰 수 있다.

_posts/algorithm/비슷한-단어/2023-10-22-채승희-비슷한-단어.md

@@ -0,0 +1,80 @@
+---
+title: 🐹 비슷한 단어
+author: chaeshee0908
+date: 2023-10-22 20:00:00 +09:00
+categories: [알고리즘, 비슷한 단어]
+tags: [알고리즘, 백준, 골드4, 문자열, 4주차, 채승희]
+render_with_liquid: false
+---
+
+## 1. 문제 링크
+
+[2469번: 비슷한 단어](https://www.acmicpc.net/problem/2179)
+
+<br>
+
+## 2. 코드
+
+`Python3` `34072kb` `824ms`
+
+```python
+from collections import Counter
+
+N = int(input())
+words = []
+max_prefix_len = 0  # 접두사의 최대 길이
+for _ in range(N):
+    word = input()
+    max_prefix_len = max(max_prefix_len, len(word))
+    words.append(word)
+
+# M의 길이의 접두사 만들고 확인 
+def check_prefix(M):
+    prefix = []
+    for w in words:
+        prefix.append(w[:M])
+    dict_prefix = Counter(prefix)
+
+    result = []
+    for key in dict_prefix.keys():
+        if dict_prefix[key] > 1:
+            result.append(key)
+    return result
+
+prefix = []
+# 가장 긴 접두사 찾기
+while max_prefix_len:
+    prefix = check_prefix(max_prefix_len)
+    if prefix:
+        break
+    max_prefix_len -= 1
+
+idx = 0
+# 접두사를 포함하는 가장 첫 단어 찾기(접두사도 찾기)
+for i in range(len(words)):
+    if words[i][:max_prefix_len] in prefix:
+        prefix = words[i][:max_prefix_len]
+        idx = i + 1
+        print(words[i])
+        break
+
+# 확정된 접두사에 해당하는 두 번째 단어 찾기
+for i in range(idx, len(words)):
+    if words[i][:max_prefix_len] == prefix:
+        print(words[i])
+        break
+```
+
+<br>
+
+## 3. 해설
+
+단어의 개수가 최대 20000개 이므로 2개의 단어씩 짝을지어 각 알파벳을 확인하여 접두사를 찾는 3중 중첩문을 사용하면 시간초과가 나므로 다른 방법을 고민해봤다. 
+
+모든 단어를 공통적인 길이로 잘라 중복되는 단어가 있다면 그것이 겹치는 접두사가 될 것이고 해당 접두사의 길이가 가장 길도록 만들어주면 된다. 이를 위해 단어에서 가장 긴 단어를 접두사의 최대 길이로 두고 반복할 때마다 길이를 1씩 줄여가며 가장 긴 접두사의 길이를 찾는다.
+
+check_prefix에서 입력된 접두사의 길이만큼 단어를 자른 후 딕셔너리로 만들어 접두사의 개수가 1이 넘게되는 접두사가 가장 긴 접두사가 된다. 이때 이를 만족하는 접두사가 여러 개 일 수 있으니 배열에 담아둔다.
+
+접두사를 찾고 난 후 입력받은 순서대로 단어를 확인하고 접두사 배열에 포함된 접두사를 가진 단어를 찾고 출력한다. 이때 어떤 접두사를 사용할지 확정된다.(접두사 배열 속에서 입력 순서가 가장 단어에 포함된 접두사)
+
+발견된 위치 다음부터 접두사가 포함된 가장 앞 순서 단어를 탐색하여 출력한다.