Merge branch 'main' of https://github.com/YoonYn9915/codingtest_algorithm_study

Author: YoonYn9915

Hongjoo/lv2/오픈채팅방.py

@@ -0,0 +1,32 @@
+"""2024.12.14, 30min , #구현"""
+def solution(record):
+    answer = []
+    # 1. history와 user_db  DB 정의 
+    user_db = {} # key=uid , value = username
+    history = [] # ["Enter / Leave" , uid ]
+    
+    #2. history와 user_db 기록 시작 
+    for r in record :
+        command = r.split() # command = [동사V ,userid ,(username)]
+        v = command[0] 
+        uid = command[1]
+         # 2-1 Enter : user_db 추가 , history 추가
+        if v == 'Enter' :
+            user_db[uid] = command[2] # user_db[uid] = username
+            history.append([uid ,v]) # history: [uid , "Enter" ]
+        #2-2 Leave :history 추가
+        elif v == 'Leave':
+            history.append([uid,v]) # history: [uid , "Leave" ]
+        #2-3 Change : user_db 수정(username 변경)
+        elif v == 'Change': 
+            user_db[uid] = command[2] #user_db[uid] = new_username
+    
+    # 3.user_db, histoy 기반으로 문자열 배열 result를 만들기         
+    result = list()
+    # 영어 v 을 한국어 동사로 번역
+    en_to_ko = {'Enter':'들어왔습니다.','Leave' : '나갔습니다.'} 
+    for uid , h_v in history : 
+        user_name = user_db[uid]
+        result.append(f"{user_name}님이 {en_to_ko[h_v]}" )
+    
+    return result

Hongjoo/백준/테트로미노.py

@@ -0,0 +1,62 @@
+"""
+2024.12.14, 과제문제, 2hour 
+"""
+
+import sys
+
+#0. 입력 변수를 통해 각 칸에 정수값을 가지는 NxM 행 graph 정의
+N,M = map(int,sys.stdin.readline().split())
+graph=[[0 for _ in range(M)] for k in range(N)]
+for i in range(N)  :
+  graph[i] = list( map(int,sys.stdin.readline().split()))
+
+max_num = 0 
+#2. graph 내 특정 칸(절대좌표 , (row,col)) 기준에서 
+#가질 수 있는 19개 형태의 테트로미노 영역 속 정수들의 합의 최대 값 찾기
+#함수 내부에선 상대좌표(r,c)로 칸의 위치 파악
+def tetries_sum (row,col):
+  sub_maxsum = 0
+  #2-1. 19개 테트로미노는 크게 4가지 직사각형 형태의 영역으로 소분류 
+  for n,m in [[1,4],[2,3],[3,2],[4,1]]: 
+    sub_sum=0 # 특정 칸(row,col)에서 가질 수 있는 정수합 중 최대값
+
+    #2-2. 19개 중 graph(NxM) 안에서 가질 수 있는 테트로미노만 적용
+    if row>=0 and row + n <=N and col>=0 and col+m <=M : 
+      #(1) 직사각형(4가지) 영역내 모든 정수값들의 합
+      for r in range(n): 
+        for c in range(m):
+          
+          sub_sum +=graph[row + r][col+ c]
+      #(2) 2x3 과 3x2 형태 영역 중 빠져야 하는 2개 칸들의 정수값의 합 구하기 
+      if n==2 and m==3 or n==3 and m==2 : 
+        del_tmp = list()
+        #a. 2x3 직사각형 영역 중 빠져야 하는 2개 칸들의 조합(상대좌표) : 10개
+        if n == 2 and m == 3 : 
+          del_candidates = [[[0,0],[0,1]],[[0,1],[0,2]],[[1,0],[1,1]],[[1,1],[1,2]],
+          [[0,0],[1,0]],[[0,2],[1,2]],[[0,0],[1,2]],[[0,2],[1,0]],[[0,0],[0,2]],[[1,0],[1,2]]
+          ]
+        #b. 3x2 직사각형 영역 중 빠져야 하는 2개 칸들의 조합(상대좌표) : 10개
+        elif n==3 and m == 2 :
+          del_candidates = [[[0,0],[0,1]],
+                            [[0,0],[1,0]],[[0,1],[1,1]],[[1,0],[2,0]],[[1,1],[2,1]],[[2,0],[2,1]],
+                            [[0,0],[2,1]],[[2,0],[0,1]],[[0,0],[2,0]],[[0,1],[2,1]]]
+        #(3) 빼야하는 2개 칸들의 조합들(10종류)에 대해 정수값의 합 구하기  
+        for n1,n2 in del_candidates:
+          del_tmp.append(graph[row +n1[0]][col+ n1[1]] +graph[row+n2[0]][col+n2[1]])
+        #(4) 2x3 또는 3x2 영역에서 합의 최대값을 구하기 위해 10개의 뺄 값 중 최소값으로 빼기
+        sub_sum -= min(del_tmp) 
+           
+      sub_maxsum = max(sub_maxsum , sub_sum) # 최대값 업데이트
+      
+       
+    else : #테트로미노가 graph 범위를 벗어남  -> skip
+      continue
+  return sub_maxsum # 절대좌표(row,col) 칸 기준에서 가질 수 있는 합의 최대
+
+max_sum = 0 #전체 graph 내 합의 최대값
+# 1. graph 내 모든 칸을 순회
+for i in range(N) :
+  for j in range(M) :
+    new_sub_sum=tetries_sum(i,j) # 2. 절대 좌표(i,j) 칸 기준에서 가질 수 있는 합의 최대 값 계산 
+    max_sum= max(max_sum,new_sub_sum)  #3.전체 graph 내 합의 최대값 업데이트
+print(max_sum)

_WeeklyChallenges/W04-[BFS]/Asssignment_BOJ_13460_구슬탈출2.py

@@ -0,0 +1,82 @@
+'''
+BOJ #13460. 구슬 탈출2 (골드2)
+https://www.acmicpc.net/problem/13460
+유형: BFS
+출처 : https://hstory0208.tistory.com/entry/Python%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EB%B0%B1%EC%A4%80-13460-%EA%B5%AC%EC%8A%AC-%ED%83%88%EC%B6%9C2
+'''
+
+from collections import deque
+import sys
+input = sys.stdin.readline
+ 
+n, m = map(int, input().split()) # 행, 열
+ 
+board = [list(input().rstrip()) for _ in range(n)]
+visited = []
+ 
+dx = [1, -1, 0, 0]
+dy = [0, 0, -1, 1]
+cnt = 0
+ 
+def getPos():
+    rx, ry, bx, by = 0, 0, 0, 0
+    for x in range(n):
+        for y in range(m):
+            if board[x][y] == "R":
+                rx, ry = x, y
+            if board[x][y] == "B":
+                bx, by = x, y
+    return rx, ry, bx, by
+ 
+ 
+def move(x, y, dx, dy):
+    cnt = 0
+    # 이동하는 위치가 벽이아니고, 구멍에 들어가지 않을 동안 반복
+    while board[x + dx][y + dy] != "#" and board[x][y] != "O":
+        x += dx
+        y += dy
+        cnt +=1
+    return x, y, cnt
+    
+def bfs():
+    rx, ry, bx, by = getPos()
+ 
+    q = deque()
+    q.append((rx, ry, bx, by, 1))
+    visited.append((rx, ry, bx, by))
+ 
+    while q:
+        rx, ry, bx, by, result = q.popleft()
+ 
+        if result > 10:
+            break
+ 
+        for i in range(4):
+            nrx, nry, rcnt = move(rx, ry, dx[i], dy[i])
+            nbx, nby, bcnt = move(bx, by, dx[i], dy[i])
+ 
+            # 파란 구슬이 구멍에 들어갈 경우
+            if board[nbx][nby] == "O":
+                continue
+ 
+            # 빨간 구슬이 들어갈 경우 성공
+            if board[nrx][nry] == "O":
+                print(result)
+                return
+ 
+            # 둘이 겹쳐있을경우 더 많이 이동한녀석을 1칸 뒤로 보낸다.
+            if nrx == nbx and nry == nby:
+                if rcnt > bcnt:
+                    nrx -= dx[i]
+                    nry -= dy[i]
+                else:
+                    nbx -= dx[i]
+                    nby -= dy[i]
+ 
+            # 탐색하지 않은 방향 탐색
+            if (nrx, nry, nbx, nby) not in visited:
+                visited.append((nrx, nry, nbx, nby))
+                q.append((nrx, nry, nbx, nby, result + 1))
+    print(-1)
+ 
+bfs()

_WeeklyChallenges/W04-[BFS]/README.md

@@ -0,0 +1,15 @@
+## 🚀 12월 3주차 (12/21) 스터디 발제 주제: BFS
+> 발제자: 김홍주
+
+### 🗂️ 스터디 자료
+- PDF: 바로가기
+- ![image](https://github.com/user-attachments/assets/64d7c010-7a67-4049-b89c-435fb767d25a)
+
+
+### 📖 문제
+- [백준 #2206. 벽 부수고 이동하기](https://www.acmicpc.net/problem/2206): 구현, BFS / 골드3
+- 정답 코드: Study_BOJ_2206_벽부수고이동하기.py
+
+### 💻 과제
+- [백준 #13460.구슬탈출2](https://www.acmicpc.net/problem/13460):  BFS / 골드2
+- 정답 코드: Asssignment_BOJ_13460_구슬탈출2.py

_WeeklyChallenges/W04-[BFS]/Study_BOJ_2206.pdf

@@ -0,0 +1,54 @@
+'''
+BOJ #2206.벽 부수고 이동하기 (골드3)
+https://www.acmicpc.net/problem/2206
+유형: BFS,구현
+'''
+
+import sys
+from collections import deque
+# 1. 입력 그래프
+N , M = map(int,sys.stdin.readline().split())
+graph = []
+for n in range(N) : 
+  graph.append(list(map(int, input())))
+
+#방문 여부 & 시작노드로 부터 최단 경로 거리 ,벽 부순 횟수(3차원) 
+visited = [[[0]*2 for _ in range(M)] for k in range(N)]
+
+#상하좌우 -> 인접 노드
+dx = [0,0,1,-1]
+dy = [1,-1,0,0]
+
+# 2. bfs 최단 거리
+def bfs():
+  #초기 노드 queue 에 추가 , 방문 등록
+  dq = deque()
+  dq.append((0,0,0))
+  visited[0][0][0] = 1 
+  
+  while dq : 
+    x,y,wall = dq.popleft()
+    # 목적지(N,M) 도착한 경우,이동 횟수 출력
+    if x == N-1 and y == M -1 : 
+      return visited[x][y][wall]
+    
+    for i in range(4):#상하좌우로 다음 이동할 칸의 위치
+      xx = x+ dx[i] ; yy = y+ dy[i]
+      # (1)다음 이동할 곳이 graph 밖에 있는 경우 
+      if xx<0 or xx>= N or yy <0 or yy>= M:
+        continue
+      # (2) 다음 이동할 곳이 벽이고, 한번도 벽 안 뚤었을때
+      if graph[xx][yy] == 1 and wall == 0 : # and not visited[xx][yy][1]
+        visited[xx][yy][1] = visited[x][y][0]+1
+        dq.append((xx,yy,1))
+      
+      #(3)다음 이동할 곳이 벽이 아니고,한번도 방문 하지 않은 곳
+      elif graph[xx][yy] == 0 and visited[xx][yy][wall] == 0 : # 그냥 감
+        visited[xx][yy][wall] = visited[x][y][wall] +1
+        dq.append((xx,yy,wall))
+      
+  return -1 #BFS 종료될떄 까지 도착점에 도달하지 못하면 -1 출력하기
+
+print(bfs())
+
+

_WeeklyChallenges/W04-[BFS]/Study_BOJ_2206_벽부수고이동하기.py

@@ -0,0 +1,51 @@
+import sys
+input = sys.stdin.readline
+
+# 테트로미노의 전체 경우의 수를 저장
+tets = [
+    # 1x4 막대
+    [(0, 1), (0, 2), (0, 3)], [(1, 0), (2, 0), (3, 0)],
+    # 2x2 정사각형
+    [(0, 1), (1, 0), (1, 1)],
+    # ㄹ자 모양
+    [(1, 0), (1, 1), (2, 1)], [(0, 1), (1, 0), (1, -1)],
+    # ㄹ자 대칭
+    [(1, 0), (1, -1), (2, -1)], [(0, 1), (1, 1), (1, 2)],
+    # ㄴ자 모양 (회전 포함)
+    [(1, 0), (2, 0), (2, 1)], [(0, 1), (0, 2), (1, 0)],
+    [(0, 1), (1, 1), (2, 1)], [(0, 1), (0, 2), (-1, 2)],
+    [(1, 0), (2, 0), (2, -1)], [(0, 1), (0, 2), (1, 2)],
+    # ㄴ자 대칭 (회전 포함)
+    [(1, 0), (2, 0), (0, 1)], [(1, 0), (1, 1), (1, 2)],
+    [(1, 0), (1, 1), (1, -1)], [(1, 0), (1, 1), (2, 0)],
+    # ㅗ자 모양 (회전 포함)
+    [(0, -1), (0, 1), (1, 0)], [(0, 1), (-1, 1), (1, 1)],
+    [(0, -1), (0, 1), (-1, 0)], [(1, 0), (0, 1), (-1, 0)],
+]
+
+# 주어진 좌표에서 특정 테트로미노를 배치했을 때의 합 계산
+def calc(i, j, tet):
+    total = arr[i][j]  # 시작 좌표의 값
+    for di, dj in tet:
+        ni, nj = i + di, j + dj
+        # 범위를 벗어나면 무효
+        if 0 <= ni < N and 0 <= nj < M:
+            total += arr[ni][nj]
+        else:
+            return 0
+    return total
+
+# 모든 위치에서 가능한 테트로미노를 배치해 최대값 계산
+def max_tetromino_sum():
+    max_sum = 0
+    for i in range(N):
+        for j in range(M):
+            for tet in tets:
+                max_sum = max(max_sum, calc(i, j, tet))
+    return max_sum
+
+
+N, M = map(int, input().split())
+arr = [list(map(int, input().split())) for _ in range(N)]
+
+print(max_tetromino_sum())

learntosurf/Implementation/2024-12-14-[BOJ]-#14500-테크로미노.py

@@ -0,0 +1,16 @@
+n = int(input())
+
+num = [[0]*10 for _ in range(n+1)]
+num[0] = [1,1,1,1,1,1,1,1,0] #0행에 들어가는 값들을 계단수의 경우의수로 초기화
+
+for i in range(1,n+1):
+    for j in range(10): #0일때, 9일때, 나머지인 경우를 점화식을 토대로 코드 작성
+        if j == 0:
+            num[i][j] = num[i-1][1]
+        elif j == 9:
+            num[i][j] = num[i-1][8]
+        else:
+            num[i][j] = num[i-1][j-1] + num[i-1][j]
+
+answer = sum(num[n]) % 100000000
+print(answer)

minjeong/DynamicProgramming/2024-12-14-[백준]-#10844-쉬운계단수.py

@@ -0,0 +1,16 @@
+# 하노이 함수
+def hanoi_f(one, three, n):
+    if n == 1:
+        print(one, three)
+        return
+
+    hanoi_f(one, 6 - one - three, n - 1)  # 1단계 (1->2)
+    print(one, three)  # 2단계 (마지막원반 1->3)
+    hanoi_f(6 - one - three, three, n - 1)  # 3단계 (2->3)
+
+
+# 메인
+n = int(input())
+print(2 ** n - 1)
+if n <= 20:
+    hanoi_f(1, 3, n)

minjeong/DynamicProgramming/2024-12-14-[백준]-#1914-하노이탑.py

@@ -0,0 +1,33 @@
+import sys
+input = sys.stdin.readline
+
+# 누적합 테이블 계산
+def get_prefix_sum(grid, N):
+    prefix_sum = [[0] * (N+1) for _ in range(N+1)]
+    for i in range(1, N+1):
+        for j in range(1, N+1):
+            prefix_sum[i][j] = (
+                grid[i-1][j-1]
+                + prefix_sum[i-1][j]
+                + prefix_sum[i][j-1]
+                - prefix_sum[i-1][j-1]
+            )
+    return prefix_sum
+
+# 입력
+N, M = map(int, input().split())
+grid = [list(map(int, input().split())) for _ in range(N)]
+
+# 누적합
+prefix_sum = get_prefix_sum(grid, N)
+
+# 범위 합 계산
+for _ in range(M):
+    x1, y1, x2, y2 = map(int, input().split())
+    answer = (
+        prefix_sum[x2][y2]
+        - prefix_sum[x1-1][y2]
+        - prefix_sum[x2][y1-1]
+        + prefix_sum[x1-1][y1-1]
+    )
+    print(answer)