[HYUNAHKO] WEEK 08 Solutions

clone-graph/HYUNAHKO.py

@@ -0,0 +1,33 @@
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+"""
+
+from typing import Optional
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+
+        if not node:
+            return None
+
+        visited = {}
+
+        def dfs(node: 'Node') -> 'Node':
+            if node.val in visited:
+                return visited[node.val]
+
+            # 노드 복제
+            cloned_node = Node(node.val)
+            visited[node.val] = cloned_node
+
+            # 이웃들 복제
+            for neighbor in node.neighbors:
+                cloned_neighbor = dfs(neighbor)
+                cloned_node.neighbors.append(cloned_neighbor)
+
+            return cloned_node
+
+        return dfs(node)

longest-repeating-character-replacement/HYUNAHKO.py

@@ -0,0 +1,35 @@
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        count = {}
+
+        # 결과를 저장할 변수 (최대 길이)
+        max_length = 0
+
+        # 윈도우 왼쪽 포인터
+        left = 0
+
+        # 현재 윈도우 내에서 가장 많이 등장한 문자의 빈도수
+        max_frequency = 0
+
+        # right 포인터를 0부터 끝까지 이동 
+        for right in range(len(s)):
+            current_char = s[right]
+
+            # 현재 문자의 카운트 증가
+            count[current_char] = count.get(current_char, 0) + 1
+
+            # 현재 윈도우 내의 '최빈 문자' 개수 갱신
+            # 새로 들어온 문자가 최빈 문자가 될 수도 있으므로 비교
+            max_frequency = max(max_frequency, count[current_char])
+
+            # 윈도우 크기 = (right - left + 1)
+            # 나머지 문자 개수 = 윈도우 크기 - 최빈 문자 개수
+            window_len = right - left + 1
+            if (window_len - max_frequency) > k:
+                # 왼쪽 문자를 윈도우에서 제거
+                left_char = s[left]
+                count[left_char] -= 1
+                left += 1  # 왼쪽 포인터 이동
+            max_length = max(max_length, right - left + 1)
+
+        return max_length

palindromic-substrings/HYUNAHKO.py

@@ -0,0 +1,20 @@
+class Solution:
+    def countSubstrings(self, s: str) -> int:
+        self.count = 0
+
+        # 중심(left, right)에서 시작해서 양옆으로 퍼지며 팰린드롬 찾기
+        def expand(left: int, right: int):
+            # 인덱스 범위를 벗어나지 않고 양쪽 문자가 같으면 팰린드롬 발견
+            while left >= 0 and right < len(s) and s[left] == s[right]:
+                self.count += 1  # 미츠케타!!!
+                left -= 1        # 왼쪽으로 한 칸 확장
+                right += 1       # 오른쪽으로 한 칸 확장
+
+        for i in range(len(s)):
+            # 홀수 길이 (중심이 i 하나) -> ex."aba"의 'b'
+            expand(i, i)
+
+            # 짝수 길이 (중심이 i와 i+1 사이) -> ex."abba"의 'bb'
+            expand(i, i + 1)
+
+        return self.count

reverse-bits/HYUNAHKO.py

@@ -0,0 +1,19 @@
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        result = []
+        quotient = n
+        while (quotient != 0):
+            remainer = quotient % 2
+
+            result.append(remainer)
+
+            quotient = quotient // 2
+
+        while len(result) < 32:
+            result.append(0)  
+
+        final_val = 0
+        for bit in result:
+            final_val = (final_val << 1) | bit
+
+        return final_val

reverse-linked-list/HYUNAHKO.py

@@ -0,0 +1,17 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+       prev = None
+       curr = head
+       while curr:
+           temp = curr.next
+           curr.next = prev
+
+           prev = curr
+           curr = temp
+
+       return prev