4 week

changyeop/BST.py

@@ -0,0 +1,68 @@
+from re import T
+
+
+class Node:
+ def __init__(self, val) -> None:
+ self.val = val
+ self.left = None
+ self.right = None
+ pass
+
+class BST:
+ def __init__(self, root: Node) -> None:
+ self.root = root
+
+ def insert(self, val):
+ self.root = self._insert_value(self.root, val=val)
+ return self.root is not None
+
+ def _insert_value(self, node, val):
+ if node is None:
+ node = Node(val)
+ else:
+ if val <= node.val:
+ node.left = self._insert_value(node.left, val)
+ else:
+ node.right = self._insert_value(node.right,val)
+ return node
+
+ def search(self, val):
+ return self._search_value(self.root, val)
+
+ def _search_value(self, root, val):
+ if root is None or root.val == val:
+ return root is not None
+ elif val < root.val:
+ return self._search_value(root.left, val)
+ else:
+ return self._search_value(root.right, val)
+
+ def delete(self, val):
+ self.root, is_deleted = self._delete_value(self.root, val)
+ return is_deleted
+
+ def _delete_value(self, node, val):
+ if node is None:
+ return node, False
+
+ is_deleted = False
+ if node.val == val:
+ is_deleted = True
+ if node.left and node.right:
+ parent, child = node, node.right
+ while child.left is not None:
+ parent, child = child, child.left
+ child.left = node.left
+ if parent != node:
+ parent.left = child.right
+ child.right = node.right
+ node = child
+ elif node.left or node.right:
+ node = node.left or node.right
+ else:
+ node = None
+ elif val < node.val:
+ node.left, is_deleted = self._delete_value(node.left, val)
+ else:
+ node.right, is_deleted = self._delete_value(node.right, val)
+ return node, is_deleted

changyeop/BubbleSort.py

@@ -0,0 +1,8 @@
+from typing import List
+
+
+def bubble(arr: List[int]):
+ for i in range(len(arr) - 1, 0, -1):
+ for j in range(i):
+ if arr[j] > arr[j+1]:
+ arr[j], arr[j+1] = arr[j+1], arr[j]

changyeop/CircularQueue.py

@@ -0,0 +1,34 @@
+class MyCircularQueue:
+ def __init__(self, k: int) -> None:
+ self.q = [None] * k
+ self.maxLen = k
+ self.p1 = 0 # front
+ self.p2 = 0 # rear
+
+ def enqueue(self, value: int):
+ if self.q[self.p2] is None:
+ self.q[self.p2] = value
+ self.p2 = (self.p2 + 1) % self.maxLen
+ return True
+ else:
+ return False
+
+ def dequeue(self):
+ if self.q[self.p1] is None:
+ return False
+ else:
+ self.q[self.p1] = None
+ self.p1 = (self.p1 + 1) % self.maxLen
+ return True
+
+ def Front(self):
+ return -1 if self.q[self.p1] is None else self.q[self.p1]
+
+ def Rear(self):
+ return -1 if self.q[self.p2 - 1] is None else self.q[self.p2 - 1]
+
+ def isEmpty(self):
+ return self.p1 == self.p2 and self.q[self.p1] is None
+
+ def isFull(self):
+ return self.p1 == self.p2 and self.q[self.p1] is not None

changyeop/Combination.py

@@ -0,0 +1,15 @@
+def combine(n: int, k: int):
+ result = []
+
+ def dfs(items, start: int, k: int):
+ if k == 0:
+ result.append(items[:])
+ return
+
+ for i in range(start, n+1):
+ items.append(i)
+ dfs(items, i+1, k-1)
+ items.pop()
+ dfs([], 1, k)
+
+ return result

changyeop/CombinationSum.py

@@ -0,0 +1,18 @@
+from typing import List
+
+
+def combinationSum(candidates: List[int], target: int):
+ result = []
+
+ def dfs(cur_sum, index, path):
+ if cur_sum > target:
+ return
+ if cur_sum == target:
+ result.append(path[:])
+ return
+
+ for i in range(index, len(candidates)):
+ dfs(cur_sum+candidates[i], i, path+[candidates[i]])
+
+ dfs(target, 0, [])
+ return result

changyeop/HeapSort.py

@@ -0,0 +1,21 @@
+def heapify(li, index, n):
+ l = index * 2 + 1
+ r = index * 2 + 2
+ s_idx = index
+ if l <= n and li[s_idx] > li[l]:
+ s_idx = l
+ if r <= n and li[s_idx] > li[r]:
+ s_idx = r
+ if s_idx != index:
+ li[index], li[s_idx] = li[s_idx], li[index]
+ return heapify(li, s_idx, n)
+def heap_sort(arr):
+ n = len(arr)
+
+ for i in range(n // 2 - 1, -1, -1):
+ heapify(arr, i, n)
+
+ for i in range(n-1, 0, -1):
+ arr[0], arr[i] = arr[i], arr[0]
+ heapify(arr, 0, i)
+ return arr

changyeop/InsertionSort.py

@@ -0,0 +1,5 @@
+def insertion(arr):
+ for end in range(1, len(arr)):
+ for i in range(end, 0, -1):
+ if arr[i-1] > arr[i]:
+ arr[i-1], arr[i] = arr[i], arr[i-1]

changyeop/Leet_3_M.py

@@ -0,0 +1,17 @@
+def lengthOfLongestSubstring(s: str) -> int:
+ # add char -> if appear contained char -> make new string : 'dvdf' 경우 틀림
+ answer = 0
+ output = ''
+ for c in s:
+ if c in output:
+ # make new string
+ start = output.index(c)
+ output = output[start+1:]
+ output += c
+ else:
+ output += c
+ answer = max(answer, len(output))
+
+ return answer
+
+print(lengthOfLongestSubstring(s='dvdf'))

changyeop/LongestSubstring.py

@@ -0,0 +1,10 @@
+def lengthOfSubstring(s: str):
+ used = {}
+ maxLen, start = 0, 0
+ for index, char in enumerate(s):
+ if char in used and start <= used[char]:
+ start = used[char] + 1
+ else:
+ maxLen = max(maxLen, index - start + 1)
+ used[char] = index
+ return maxLen

changyeop/MergeSort.py

@@ -0,0 +1,22 @@
+def merge_sort(arr):
+
+ if len(arr) < 2:
+ return arr
+
+ mid = len(arr) // 2
+ low_arr = merge_sort(arr[:mid])
+ high_arr = merge_sort(arr[mid:])
+
+ merged_arr = []
+
+ l = h = 0
+ while l < len(low_arr) and h < len(high_arr):
+ if low_arr[l] < high_arr[h]:
+ merged_arr.append(low_arr[l])
+ l += 1
+ else:
+ merged_arr.append(high_arr[h])
+ h += 1
+ merged_arr += low_arr[l:]
+ merged_arr += low_arr[:h]
+ return merged_arr

changyeop/MostCommonWord.py

@@ -0,0 +1,9 @@
+from collections import Counter
+import re
+from typing import List
+
+
+def solution(paragraph: str, banned: List[str]):
+ words = [w for w in re.sub(r'[^\w]', ' ', paragraph).lower().split() if w not in banned]
+ counts = Counter(words)
+ return counts.most_common(1)[0][0]

changyeop/Permutation.py

@@ -0,0 +1,21 @@
+from typing import List
+
+
+def permute(nums: List[int]):
+ result = []
+ perm = []
+
+ def dfs(items):
+ if len(items) == 0:
+ result.append(perm[:])
+ return
+ for i in items:
+ next_items = items[:]
+ next_items.remove(i)
+ perm.append(i)
+ dfs(next_items)
+ perm.pop()
+
+ dfs(nums)
+
+ return result

changyeop/QueueByStack.py

@@ -0,0 +1,20 @@
+class MyQueue:
+ def __init__(self) -> None:
+ self.input = []
+ self.output = []
+
+ def push(self, x):
+ self.input.append(x)
+
+ def peek(self):
+ if not self.output:
+ while self.input:
+ self.output.append(self.input.pop())
+ return self.output[-1]
+
+ def pop(self):
+ self.peek()
+ return self.output.pop()
+
+ def empty(self):
+ return self.input == [] and self.output == []

changyeop/QuickSort.py

@@ -0,0 +1,14 @@
+def quick_sort(arr):
+ if len(arr) <= 1:
+ return arr
+
+ pivot = arr[len(arr) // 2]
+ min_arr, equal_arr, max_arr = [], [], []
+ for num in arr:
+ if num < pivot:
+ min_arr.append(num)
+ elif num > pivot:
+ max_arr.append(num)
+ else:
+ equal_arr.append(num)
+ return quick_sort(min_arr) + equal_arr + quick_sort(max_arr)