Merge branch '24-Algorithm:main' into main

Author: YoonYn9915

.DS_Store

@@ -0,0 +1,27 @@
+"""
+ (1)평행선 -> 같은 기울기
+(2) 두 직선이 일치하는 경우도 
+"""
+
+def solution(dots):
+    # 모든 직선의 기울기 구하기
+    # 1. 점 2개 선택 
+    # 2. 기울기 
+    answer = 0
+    loops= []
+    
+    for i in range(len(dots)) :
+        for j in range(i+1, len(dots)) : 
+            x1 , y1 = dots[i]
+            x2 , y2 = dots[j]
+            print(f"### {x1} ,{y1} , {x2} , {y2}")
+            output= (y1-y2)/(x1-x2+0.0001)
+            loop = abs(output)
+            print(f"##{loop}")
+            for l in loops : 
+                if loop == l : 
+                    return  1 
+            loops.append(loop)
+    print("$" ,loops)    
+
+    return answer

Hongjoo/lv0/평행.py

@@ -0,0 +1,60 @@
+'''
+LZW
+1. Dic = {seq_length = 1  단어들 }
+
+2. in Dic 현재 입력 matching 된 단어중 가장 max length  가진 문자열 찾기  => w 
+3.print(W의 index), input 에서 제거 pop
+4 입력에서 처리 되지 않은 다음 글자 c  있으면 -> w+c를 사전에 등재 
+5.2로 regress 
+| condition
+1. 대문자만 
+2,dic_index : 1 ~ 
+
+'''
+dic = [0 , "A" , "B" , "C" , "D" ,"E", "F" , "G" , "H" , "I" , "J" , "K" , "L", "M" , "N" , "O", "P", "Q", "R", "S" , "T" , "U" , "V" , "W", "X" , "Y" , "Z"] 
+def compression_check(left_w , dic):
+    # 1 . dic에 w 의 여부
+    # 2. W 와 total_c  찾기 : 2point matching 된 단어중 가장 max length -
+    # answer =[] ; 
+    count = 0
+    i = 0; j = len(left_w) #  i : start ,j : end 
+    while i != j and j >= 0: # c가 없음 -> 끝
+        # print("1" ,left_w[i:j]  ,i , j)
+        count+=1
+        if left_w[i:j]in dic : 
+            print("2"  , i, j)          
+            w = left_w[i:j] 
+            c = left_w[j]
+            dic.append(w+c)
+            print(w ,c,dic)
+            idx = dic.index(w)
+            # answer.append(idx)
+            print("w_idx" , idx)
+            # left_w = "" + c  # 초기화
+            i = j #업데이트 
+            return idx , j 
+            # print("#" , w , c , dic , left_w)
+            
+        # print("-1")
+        j=j-1
+        # print(j)
+
+        
+def solution(msg):
+    answer = []    
+    
+    
+    # 1. inintialize dic
+    # dic = [0 , "A" , "B" , "C" , "D" ,"E", "F" , "G" , "H" , "I" , "J" , "K" , "L", "M" , "N" , "O", "P", "Q", "R", "S" , "T" , "U" , "V" , "W", "X" , "Y" , "Z"] # total 26 + "0" = 1 -> 1~ 26 only valid
+    #2. 
+    a = 0 ; c ="a"
+    answer = []
+    a , j_c  = compression_check(msg , dic)
+    answer.append(a)
+    
+    while j_c > 0 : 
+        a,j_c = compression_check(msg[j_c:] , dic)
+        print(a)
+    
+    # print("####", answer)
+    return answer

Hongjoo/lv2/압축.py

@@ -0,0 +1,25 @@
+n = int(input())
+origin = [int(n) for n in input().split()]  # 4,1,5,2,3
+m = int(input())
+compare = [int(m) for m in input().split()]  # 1,3,7,9,5
+
+origin.sort()  # 1,2,3,4,5
+
+for i in range(m):  #
+    tag = False
+    low = 0
+    high = len(origin) - 1
+    target = compare[i]  # 5
+    while low <= high:
+        mid = (low + high) // 2
+        if origin[mid] == target:
+            tag = True
+            print(1)
+            break
+        elif origin[mid] > target:
+            high = mid - 1
+        else:
+            low = mid + 1
+
+    if tag is False:
+        print(0)

minjeong/BinarySearch/2024-09-19-[백준]-#1920-수찾기.py

@@ -0,0 +1,50 @@
+# PGS. 2024 KAKAO WINTER INTERNSHIP - 가장 많이 받은 선물
+def solution(friends, gifts):
+    gift_map = {}  # 각 친구 쌍 간 선물 기록
+    send_count = {}  # 선물 준 횟수 딕셔너리
+    receive_count = {}  # 선물 받은 횟수 딕셔너리
+    gift_count = {}  # 선물 지수 딕셔너리
+    next_month_gift_cnt = {}  # 다음 달에 받을 선물의 개수를 친구들별로 저장하는 딕셔너리
+
+    for friend in friends: # 초기화
+        gift_map[friend] = {}
+        send_count[friend] = 0
+        receive_count[friend] = 0
+        gift_count[friend] = 0
+        next_month_gift_cnt[friend] = 0
+
+    # 선물 기록 분석(각 친구 간에 누가 몇 번 선물을 주고받았는지)
+    for gift in gifts:
+        sender, receiver = gift.split()
+        if receiver not in gift_map[sender]: # 해당 친구 간의 기록이 없다면 0으로 초기화
+            gift_map[sender][receiver] = 0
+        if sender not in gift_map[receiver]: # 해당 친구 간의 기록이 없다면 0으로 초기화
+            gift_map[receiver][sender] = 0
+        gift_map[sender][receiver] += 1 # sender가 receiver에게 선물한 횟수 +1
+
+        send_count[sender] += 1         # sender가 준 선물 횟수 +1
+        receive_count[receiver] += 1    # receiver가 받은 선물 횟수 +1
+
+    # 선물 지수 계산
+    for friend in friends:
+        # 선물지수: 준 선물 수 - 받은 선물 수
+        gift_count[friend] = send_count[friend] - receive_count[friend]
+
+    # 모든 친구 쌍을 비교하여 다음 달에 받을 선물 수 계산
+    for i in range(len(friends)):
+        for j in range(i + 1, len(friends)):
+            A = friends[i]
+            B = friends[j]
+            if gift_map[A].get(B, 0) > gift_map[B].get(A, 0): # A>B이면, A가 다음달에 받음
+                next_month_gift_cnt[A] += 1
+            elif gift_map[A].get(B, 0) < gift_map[B].get(A, 0): #A<B이면, B가 다음달에 받음
+                next_month_gift_cnt[B] += 1
+            else:  # 두 사람이 주고받은 수가 같다면, 선물 지수가 더 큰 사람이 받음
+                if gift_count[A] > gift_count[B]:
+                    next_month_gift_cnt[A] += 1
+                elif gift_count[A] < gift_count[B]:
+                    next_month_gift_cnt[B] += 1
+                # 선물 지수도 같다면 아무도 받지 않음
+
+    # 가장 많이 받을 친구 반환
+    return max(next_month_gift_cnt.values())

minjeong/BruteForce/2024-09-12-[PGS]-가장많이받은선물.py

@@ -0,0 +1,35 @@
+'''
+양 모은 수보다 늑대의 수가 같거나 많아지면 종료됨
+부모 노드는 방문했지만 자식 노드는 방문하지 않았을 때 방문할 수 있음
+
+'''
+
+
+def solution(info, edges):
+    # info - 0: 양, 1: 늑대
+    global answer
+    answer = 0
+    visited = [False] * len(info)
+    visited[0] = True  # 0번 노드는 항상 양이 있음
+
+    def dfs(sheep, wolf):
+        global answer
+
+        if wolf < sheep:  # 양이 늑대보다 더 많으면 모을 수 있는 최대 양 마리 수 업데이트
+            answer = max(answer, sheep)
+        else:  # 늑대가 양의 수와 같거나 더 많을 경우 종료됨
+            return
+
+        for parent, child in edges:
+            # 부모 노드는 방문했지만 자식 노드는 방문하지 않았을 때
+            if visited[parent] and not visited[child]:
+                visited[child] = True
+                if info[child] == 0:  # 양이라면 양 마리 수 + 1
+                    dfs(sheep + 1, wolf)
+                else:  # 늑대라면 늑대 마리 수 + 1
+                    dfs(sheep, wolf + 1)
+                visited[child] = False
+
+    dfs(1, 0)  # (sheep, wolf)
+
+    return answer

minjeong/DFSBFS/2024-09-09-[PGS]-#양과늑대.py

@@ -0,0 +1,18 @@
+import sys
+input = sys.stdin.readline
+
+n = int(input()) # 수 입력 받기
+t, p = [0 for _ in range(n + 1)], [0 for _ in range(n + 1)]
+for i in range(1, n + 1):
+    t[i], p[i] = map(int, input().split())
+dp = [0] * (n+1) #dp 리스트 초기화
+
+for i in range(1, n+1):
+    time = t[i]
+    pay = p[i]
+    day = i + time - 1
+    dp[i] = max(dp[i], dp[i - 1])  # 이전까지의 최댓값
+    if day <= n:
+        dp[day] = max(dp[day], dp[i-1]+pay)
+
+print(max(dp))

minjeong/DynamicProgramming/2024-09-21-[백준]-#15486-퇴사2.py

@@ -0,0 +1,51 @@
+import sys
+input = sys.stdin.readline
+
+
+def check_winner(x, y, color):
+    # 오목 4개 방향
+    directions = [(-1, 0), (0, -1), (-1, -1), (-1, 1)]
+    # (-1, 0) - 세로 방향 (위쪽)
+    # (0, -1) - 가로 방향 (왼쪽)
+    # (-1, -1) - 좌상향 대각선 방향
+    # (-1, 1) - 우상향 대각선 방향
+
+    for dx, dy in directions:
+        count = 1  # 현재 돌이 포함된 연속된 돌의 개수를 셀 변수 초기화
+
+        # 주어진 방향으로 연속된 돌 개수 세기
+        nx, ny = x + dx, y + dy
+        while 1 <= nx < 20 and 1 <= ny < 20 and board[nx][ny] == color:
+            count += 1
+            # 방향 dx, dy로 이동하며 해당 방향에 같은 색의 돌이 있는 한 계속 탐색
+            nx += dx
+            ny += dy
+
+        # 반대 방향으로도 연속된 돌 개수 세기
+        nx, ny = x - dx, y - dy
+        while 1 <= nx < 20 and 1 <= ny < 20 and board[nx][ny] == color:
+            count += 1
+            # 반대 방향으로도 이동하여 연속된 돌의 개수를 추가로 셈
+            nx -= dx
+            ny -= dy
+
+        # 5개일 경우만 승리로 인정
+        if count == 5:
+            return True
+
+    return False # 5개의 돌이 연속되지 않을 경우
+
+N = int(input().strip())  # 돌의 개수
+board = [[0] * 20 for _ in range(20)]  # 19x19 바둑판 / 바둑돌이 놓인 위치 기록 (1,1)~(19,19)
+
+# 입력된 좌표에 돌을 기록
+for i in range(N):
+    x, y = map(int, input().strip().split()) # 각 수의 좌표
+    color = 1 if i % 2 == 0 else 2 # 홀수 번째 수: 흑돌(1), 짝수 번째 수: 백돌(2)
+    board[x][y] = color # 해당 좌표에 돌을 놓음 (바둑판 배열에 기록)
+
+    if check_winner(x, y, color): # 현재 놓은 돌로 인해 승리가 결정되는지 확인
+        print(i + 1)              # 승리가 결정되면 현재 몇 번째 수인지 출력하고 프로그램 종료
+        sys.exit()
+
+print(-1) # 모든 돌을 놓았지만 승패가 결정되지 않으면 -1 출력

minjeong/Simulation/2024-09-04-[백준]-#2072-오목.py

@@ -0,0 +1,10 @@
+K = int(input())
+stack = []
+for i in range(K):
+    num = int(input())
+    stack.append(num)
+    if num == 0:
+        stack.pop()
+        stack.pop()
+
+print(sum(stack))