move algorithm repository to TIL

Author: aohus

README.md

@@ -1,2 +1,7 @@
 # TIL
-Today I Learned- 매일 보고 들은 모든 것
+
+## Today I Learned- 매일 보고 들은 모든 것
+
+## daily note
+
+## books

_dailynote/2023-08-28.md

@@ -13,9 +13,9 @@
 
 실습과 그림으로 배우는 리눅스 구조
 
-- [ch1*컴퓨터*시스템의\_개요](../books/실습과%20그림으로%20배우는%20리눅스%20구조/ch1_컴퓨터_시스템의_개요.md)
-- [ch2*사용자*모드로*구현되는*기능](../books/실습과%20그림으로%20배우는%20리눅스%20구조/ch2_사용자_모드로_구현되는_기능.md)
-- [ch3*프로세스*관리](../books/실습과%20그림으로%20배우는%20리눅스%20구조/ch3_프로세스_관리.md)
+- [ch1 컴퓨터 시스템의 개요](../os/실습과%20그림으로%20배우는%20리눅스%20구조/ch1_컴퓨터_시스템의_개요.md)
+- [ch2 사용자 모드로 구현되는 기능](../os/실습과%20그림으로%20배우는%20리눅스%20구조/ch2_사용자_모드로_구현되는_기능.md)
+- [ch3 프로세스 관리](../os/실습과%20그림으로%20배우는%20리눅스%20구조/ch3_프로세스_관리.md)
 
 파이썬
 

algorithm/DynamicProgramming/dp_climning_stairs.py

@@ -0,0 +1,28 @@
+"""
+link : https://leetcode.com/problems/climbing-stairs/
+"""
+
+
+class Solution:
+    def cs(self, n):
+        pass
+
+    # top-down(memorization) 방식
+
+    def cs_topdown(self, n):
+        memo = {}
+        if n == 1:
+            return 1
+        if n == 2:
+            return 2
+        if n not in memo:
+            memo[n] = self.cs_topdown(n - 1) + self.cs_topdown(n - 2)
+        return memo[n]
+
+    # bottom-up(tabulation, dp table) 방식
+
+    def cs_bottomup(self, n):
+        memo = {1: 1, 2: 2}
+        for i in range(3, n + 1):
+            memo[i] = memo[i - 1] + memo[i - 2]
+        return memo[n]

algorithm/DynamicProgramming/fibo.py

@@ -0,0 +1,36 @@
+def fibo_basic(n):
+    if n < 3:
+        return 1
+    return fibo(n - 1) + fibo(n - 2)
+
+
+memo = {1: 1, 2: 1}
+
+
+def fibo_memo(n):
+    if n in memo:
+        return memo[n]
+    memo[n] = fibo(n - 2) + fibo(n - 1)
+    return memo[n]
+
+
+def fibo_deco(func):
+    memo = {1: 1, 2: 1}
+
+    def inner(n):
+        if n in memo:
+            return memo[n]
+        memo[n] = func(n)
+        return memo[n]
+
+    return inner
+
+
+@fibo_deco
+def fibo(n):
+    if n < 3:
+        return 1
+    return fibo(n - 1) + fibo(n - 2)
+
+
+print(fibo(100))

algorithm/DynamicProgramming/recursion_combinations.py

@@ -0,0 +1,59 @@
+"""
+link: https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/
+방법1: digits 길이에 제한이 있다면 사용 불가에 가까움. 
+방법2 : recursion으로 푸는 방법 추가.
+    - 그래프 전체를 탐색하는 것과 같음.
+"""
+from typing import List
+
+
+class Solution:
+    def letterCombinations(self, digits: str) -> List[str]:
+        if digits == "":
+            return digits
+
+        len_digits = len(digits)
+        num_mapping = {
+            "2": "abc",
+            "3": "def",
+            "4": "ghi",
+            "5": "jkl",
+            "6": "mno",
+            "7": "pqrs",
+            "8": "tuv",
+            "9": "wxyz",
+        }
+        first = num_mapping[digits[0]] if len_digits > 0 else [""]
+        second = num_mapping[digits[1]] if len_digits > 1 else [""]
+        third = num_mapping[digits[2]] if len_digits > 2 else [""]
+        forth = num_mapping[digits[3]] if len_digits > 3 else [""]
+        return [
+            a + b + c + d for a in first for b in second for c in third for d in forth
+        ]
+
+    def letterCombinationsRecursion(self, digits: str) -> List[str]:
+        if not digits:
+            return []
+
+        phone = {
+            "2": "abc",
+            "3": "def",
+            "4": "ghi",
+            "5": "jkl",
+            "6": "mno",
+            "7": "pqrs",
+            "8": "tuv",
+            "9": "wxyz",
+        }
+        res = []
+
+        def backtrack(combination, next_digits):
+            if not next_digits:
+                res.append(combination)
+                return
+
+            for letter in phone[next_digits[0]]:
+                backtrack(combination + letter, next_digits[1:])
+
+        backtrack("", digits)
+        return res

algorithm/Graph/graph_bfs.py

@@ -0,0 +1,23 @@
+from collections import deque
+
+
+def bfs(graph, start_v):
+    visited = [start_v]
+    queue = deque(start_v)
+    while queue:
+        cur_v = queue.popleft()
+        for v in graph[cur_v]:
+            if v not in visited:
+                visited.append(v)
+                queue.append(v)
+    return visited
+
+
+graph = {
+    "A": ["B", "D", "E"],
+    "B": ["A", "C", "D"],
+    "C": ["B"],
+    "D": ["A", "B"],
+    "E": ["A"],
+}
+bfs(graph, "A")

algorithm/Graph/graph_combination_sum.py

@@ -0,0 +1,32 @@
+from typing import List 
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        answer=[]
+        def dfs(elements:List[int], start:int) :
+            if sum(elements) == target :
+                answer.append(elements[:])
+                return 
+            if sum(elements) > target :
+                return
+            
+            for i in candidates[start:]:
+                elements.append(i)
+                dfs(elements, candidates.index(i))
+                elements.pop()
+        dfs([],0)
+        return answer
+    
+    def combinationSumFast(self, candidates: List[int], target: int) -> List[List[int]]:
+        answer=[]
+        def dfs(csum, index, path) :
+            if csum ==  0:
+                answer.append(path)
+                return 
+            if csum < 0 :
+                return
+            
+            for i in range(index, len(cantidates)):
+                dfs(csum-candidates[i], i, path+[candidates[i]])
+        dfs(target,0,[])
+        return answer

algorithm/Graph/graph_combine.py

@@ -0,0 +1,58 @@
+from typing import List 
+import itertools
+
+class Solution:
+    def combineWrong(self, n: int, k: int) -> List[List[int]]:
+        answer = []
+        def dfs(combine, elements):
+            for e in elements :
+                combine.append(e)
+                if len(combine) == k :
+                    answer.append(combine[:])
+                    combine.pop()
+                    continue                 
+                next_elements = [ i for i in elements if i > e ]
+                dfs(combine, next_elements)
+                combine.pop()
+        
+        elements = [ i for i in range(1, n+1) ]
+        dfs([],elements)
+        return answer
+    
+    def combineDirty(self, n: int, k: int) -> List[List[int]]:
+        answer = []
+        def dfs(elements, rest):
+            for r in rest :
+                elements.append(r)
+                if len(elements) == k :
+                    answer.append(elements[:])
+                    elements.pop()
+                    continue
+                next = [ i for i in rest if i > r ]
+                dfs(elements, next)
+                elements.pop()
+
+        elements = [ i for i in range(1, n+1) ]
+        dfs([],elements)
+        return answer
+
+    def combine(self, n:int, k:int) -> List[List[int]]:
+        answer=[]
+        def dfs(elements, start: int, k: int):
+            if k == 0 :
+                answer.append(elements[:])
+                return
+            for i in range(start, n+1):
+                # elements.append(i)
+                # dfs(elements, i+1, k-1)
+                # elements.pop()
+                dfs(elements+[i], i+1, k-1)
+        dfs([],1,k)
+        return answer
+
+    def combineTools(self, n, k):
+        return list(itertools.combinations(range(1,n+1), k))
+S=Solution()
+print(S.combineWrong(5,3))
+# print(S.combine(3,2))
+# print(S.combineTools(3,2))

algorithm/Graph/graph_dfs.py

@@ -0,0 +1,40 @@
+graph = {
+    "A": ["B", "D", "E"],
+    "B": ["A", "C", "D"],
+    "C": ["B"],
+    "D": ["A", "B"],
+    "E": ["A"],
+}
+visited = []
+
+
+def dfs(cur_v):
+    visited.append(cur_v)
+    for v in graph[cur_v]:
+        if v not in visited:
+            dfs(v)
+
+
+dfs(graph, "A")
+
+
+def traversal(root):
+    if root is None:
+        return
+    traversal(root.left)
+    traversal(root.right)
+
+
+import json
+
+student_data = {}
+with open("student_file.json", "w") as f:
+    json.dump(student_data, f)
+
+with open("student_file.json", "r") as f:
+    st_python = json.load(f)
+
+# python 메모리에 있는 json fotmat data를 python 객체로 읽기
+# 언제쓰나?
+st_json = json.dumps(student_data)
+st_python2 = json.loads(st_json)

algorithm/HashTable/dictionary_longest_sequence.py

@@ -0,0 +1,45 @@
+"""
+link : https://leetcode.com/problems/longest-consecutive-sequence/
+"""
+from typing import List
+
+
+class Solution:
+    def longest_sequence(nums: List[int]) -> int:
+        num_dict = {}
+        count_set = set()
+        for num in nums:
+            num_dict[num] = 1
+        for num in nums:
+            if num - 1 not in num_dict:
+                selected = num
+                count = 1
+                while selected + 1 in num_dict:
+                    count += 1
+                    selected += 1
+                    count_set.add(count)
+                # longest = max(longest, count) return longest
+        return max(count_set) if len(count_set) > 0 else 0
+
+    def longest_sequence_sorted(nums: List[int]) -> int:
+        nums = sorted(nums, reverse=True)
+        count_set = set()
+        count = 1
+        for i in range(1, len(nums)):
+            if nums[i - 1] == nums[i] + 1:
+                count += 1
+                count_set.add(count)
+            else:
+                count = 1
+        return max(count_set) if len(count_set) > 0 else 0
+
+
+S = Solution
+print(S.longest_sequence([100, 4, 200, 1, 3, 2]) == 4)
+print(S.longest_sequence_sorted([100, 4, 200, 1, 3, 2]) == 4)
+print(
+    S.longest_sequence([100, 4, 200, 1, 3, 2, 101, 102, 103, 104, 5, 105, 107, 106])
+    == 8
+)
+print(S.longest_sequence([100, 4, 200, 1, 10, 14]) == 0)
+print(S.longest_sequence_sorted([100, 4, 200, 1, 10, 14]) == 0)

algorithm/HashTable/dictionary_longest_substring.py

@@ -0,0 +1,35 @@
+"""
+link:https://leetcode.com/problems/longest-substring-without-repeating-characters/description/
+"""
+
+
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        length = 0
+        substring = ""
+        for i in s:
+            if i not in substring:
+                substring += i
+                length = max(length, len(substring))
+            else:
+                idx = substring.find(i)
+                substring += i
+                substring = substring[idx + 1 :]
+        return length
+
+
+# class Solution:
+#     def lengthOfLongestSubstring(self, s: str) -> int:
+#         seen = {}
+#         l = 0
+#         output = 0
+#         for r in range(len(s)):
+#             if s[r] not in seen:
+#                 output = max(output,r-l+1)
+#             else:
+#                 if seen[s[r]] < l:
+#                     output = max(output,r-l+1)
+#                 else:
+#                     l = seen[s[r]] + 1
+#             seen[s[r]] = r
+#         return output

algorithm/HashTable/dictionary_two_sum.py

@@ -0,0 +1,33 @@
+"""
+link: https://leetcode.com/problems/two-sum/
+"""
+from typing import List, Union
+
+
+class Solution:
+    def two_sum(nums: List[int], target: int) -> Union[List[int], bool]:
+        memo = {}
+        for idx, num in enumerate(nums):
+            if target - num in memo:
+                return [memo[target - num], idx]
+            memo[num] = idx
+        return False
+
+    # True False 만 반환해도 될 때
+    def two_sum_tf(nums: List[int], target: int) -> bool:
+        memo = {}  # dictionary의 목적이 이름에 드러나니 더 좋음
+        for k in nums:
+            needed_number = target - k  # 변수 따로 선언해서 담아주니까 가독성이 훨씬 좋음
+            if memo.get(needed_number, None):
+                return True
+            memo[k] = 1
+        return False
+
+
+S = Solution
+print(S.two_sum([4, 1, 9, 7, 5, 3, 16], 13) == [0, 2])
+print(S.two_sum([4, 1, 9, 7, 5, 3, 16], 50) is False)
+print(S.two_sum([4, 1, 1, 6], 2) == [1, 2])
+print(S.two_sum_tf([4, 1, 9, 7, 5, 3, 16], 13) is True)
+print(S.two_sum_tf([4, 1, 9, 7, 5, 3, 16], 50) is False)
+print(S.two_sum_tf([4, 1, 1, 6], 2) is True)

algorithm/List/dynamic_array_design_browser_history.py

@@ -0,0 +1,3 @@
+"""
+link: https://leetcode.com/problems/design-browser-history/
+"""

algorithm/List/dynamic_array_max_profit.py

@@ -0,0 +1,17 @@
+"""
+link : https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/
+"""
+from typing import List
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        min_price = prices[0]
+        for price in prices:
+            profit = price - min_price
+            if profit > max_profit:
+                max_profit = profit
+            if price < min_price:
+                min_price = price
+        return max_profit

algorithm/List/dynamic_array_move_zeroes.py

@@ -0,0 +1,33 @@
+from typing import List
+
+"""
+link: https://leetcode.com/problems/move-zeroes/
+use swapping
+"""
+
+
+class Solution:
+    def moveZeroes(self, nums: list) -> None:
+        slow = 0
+        for fast in range(len(nums)):
+            if nums[fast] != 0 and nums[slow] == 0:
+                nums[slow], nums[fast] = nums[fast], nums[slow]
+
+            # wait while we find a non-zero element to
+            # swap with you
+            if nums[slow] != 0:
+                slow += 1
+
+    def moveZeroes_remove(self, nums: List[int]) -> None:
+        if not any(nums):
+            return
+
+        num_of_zero = 0
+        while 0 in nums:
+            nums.remove(0)
+            num_of_zero += 1
+        nums.extend([0] * num_of_zero)
+
+
+s = Solution()
+print(s.moveZeroes([0, 0, 0, 0, 0, 0, 0, 0, 0]))

algorithm/List/dynamic_array_remove_duplicate.py

@@ -0,0 +1,26 @@
+"""
+link : https://leetcode.com/problems/remove-duplicates-from-sorted-array/
+
+Given an integer array nums sorted in non-decreasing order, remove the duplicates **in-place** such that each unique element appears only once. 
+The relative order of the elements should be kept the same. Then return the number of unique elements in nums.
+
+**in-place**
+입력 크기에 비례하는 추가 공간을 요구하지 않고 입력 데이터 구조 에서 직접 작동하는 알고리즘.
+데이터 구조의 별도 복사본을 만들지 않고 입력을 제자리에서 수정함. 
+=> 별도의 list 만들지 않고 구해라~~ 
+"""
+from typing import List
+
+
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        j = 0
+        for i in range(1, len(nums)):
+            if nums[j] != nums[i]:
+                j += 1
+                nums[j] = nums[i]
+        return j + 1
+
+
+s = Solution()
+print(s.removeDuplicates([0, 0, 0, 1, 1, 2, 3, 3, 4]) == 5)

algorithm/List/dynamic_array_search_insert_position.py

@@ -0,0 +1,18 @@
+"""
+Link : https://leetcode.com/problems/search-insert-position/
+using binary search for O(log(n)) complexity.
+insert 위치 찾는 것은 while 문에 index 끼리 비교하고 index 를 update.
+"""
+from typing import List
+
+
+class Solution:
+    def searchInsert(self, nums: List[int], target: int) -> int:
+        min_idx, max_idx = 0, len(nums)
+        while min_idx < max_idx:
+            cur_idx = (min_idx + max_idx) // 2
+            if target > nums[cur_idx]:
+                min_idx = cur_idx + 1
+            else:
+                max_idx = cur_idx
+        return min_idx

algorithm/List/dynamic_array_single_number.py

@@ -0,0 +1,25 @@
+"""
+link : https://leetcode.com/problems/single-number-ii/description/
+Given an integer array nums where every element appears three times except for one, which appears exactly once. Find the single element and return it.
+You must implement a solution with a **linear runtime complexity and use only constant extra space.**
+"""
+from typing import List
+from collections import defaultdict
+
+
+class Solution:
+    def singleNumber_no_o1_space(self, nums: List[int]) -> int:
+        mydict = defaultdict(int)
+        for i in nums:
+            mydict[i] = mydict[i] + 1
+        return list(mydict.keys())[list(mydict.values()).index(1)]
+
+    def singleNumber(self, nums: List[int]) -> int:
+        ones = 0
+        twos = 0
+
+        for num in nums:
+            ones ^= num & ~twos
+            twos ^= num & ~ones
+
+        return ones

algorithm/List/dynamic_array_trapping_water_fall.py

@@ -0,0 +1,50 @@
+"""
+link: https://leetcode.com/problems/trapping-rain-water/
+"""
+
+from typing import List
+
+
+class Solution:
+    def trap_two_pointer(self, height: List[int]) -> int:
+        if not height:
+            return 0
+        volume = 0
+        left, right = 0, len(height) - 1
+        left_max, right_max = height[left], height[right]
+
+        while left < right:
+            left_max, right_max = max(height[left], left_max), max(
+                height[right], right_max
+            )
+            if left_max <= right_max:
+                volume += left_max - height[left]
+                left += 1
+            else:
+                volume += right_max - height[right]
+                right -= 1
+        return volume
+
+    # 스택으로 풀이
+    def trap_stack(self, height: List[int]) -> int:
+        stack = []
+        volume = 0
+
+        for i in range(len(height)):
+            print(stack)
+            while stack and height[i] > height[stack[-1]]:
+                top = stack.pop()
+
+                if not len(stack):
+                    break
+                distance = i - stack[-1] - 1
+                waters = min(height[i], height[stack[-1]]) - height[top]
+
+                volume += distance * waters
+            stack.append(i)
+        return volume
+
+
+S = Solution()
+print(S.trap_two_pointer([0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]))
+print(S.trap_stack([0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]))

algorithm/List/dynamic_array_two_sum.py

@@ -0,0 +1,23 @@
+"""
+link: https://leetcode.com/problems/two-sum/
+
+for 문 두 번 돌지 않고 O(n)으로 풀이
+-> remaining 을 구해서 dictionary에 저장하고 찾는 방식. value in dict 는 O(1)연산으로 빨라서 이용할 수 있다면 유리함. 
+"""
+from typing import List
+
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        seen = {}
+        for i, value in enumerate(nums):
+            remaining = target - nums[i]
+
+            if remaining in seen:
+                return [i, seen[remaining]]
+            else:
+                seen[value] = i
+
+
+s = Solution()
+print(s.twoSum([3, 2, 4], 6))

algorithm/List/linked_list_add_two_numbers.py

@@ -0,0 +1,38 @@
+"""
+link : https://leetcode.com/problems/add-two-numbers
+파이썬 알고리즘 인터뷰 참고
+"""
+
+
+class ListNode:
+    def __init__(self, value=0, next=None):
+        self.val = value
+        self.next = next
+
+
+class Solution:
+    def add_two_numbers(self, l1: ListNode, l2: ListNode) -> ListNode:
+        root = head = ListNode(0)
+
+        carry = 0
+        while l1 or l2 or carry:
+            sum = 0
+            # 두 입력값의 합 계산
+
+            if l1:
+                sum += l1.val
+                l1 = l1.next
+            if l2:
+                sum += l2.val
+                l2 = l2.next
+
+            # 몫(자리올림수)과 나머지(값) 계산
+            carry, val = divmod(sum + carry, 10)
+            head.next = ListNode(val)
+            head = head.next
+
+        return root.next
+
+
+s = Solution()
+print(s.add_two_numbers(l1=[2, 4, 3], l2=[5, 6, 4]))

algorithm/List/linked_list_design_browser_history.py

@@ -0,0 +1,77 @@
+"""
+link: https://leetcode.com/problems/design-browser-history/
+"""
+
+
+class Site:
+    def __init__(self, url=0, next=None, previous=None):
+        self.url = url
+        self.next = next
+        self.previous = previous
+
+
+class BrowserHistory(object):
+    def __init__(self, url):
+        self.head = self.current = Site(url=url)
+        # 아래 처럼 따로 선언하면 Site 가 각각 생성되는 것임. head & current가 같은 객체가 아니게 됨.
+        # self.head = Site(url=url)
+        # self.current = Site(url=url)
+
+    def visit(self, url):
+        new_site = Site(url=url, previous=self.current)
+        self.current.next = new_site
+        self.current = self.current.next
+        # current = self.head
+        # while current.next:
+        #     current = current.next
+        # current.next = new_site
+        # self.now = new_site
+
+    def back(self, steps):
+        while steps > 0 and self.current.previous is not None:
+            steps -= 1
+            self.current = self.current.previous
+        # current = self.now
+        # for _ in range(steps):
+        #     if current.previous:
+        #         current = current.previous
+        #     else:
+        #         self.now = current
+        #         return current
+        # self.now = current
+        return self.current.url
+
+    def forward(self, steps):
+        while steps > 0 and self.current.next is not None:
+            steps -= 1
+            self.current = self.current.next
+        # current = self.now
+        # for _ in range(steps):
+        #     if current.next:
+        #         current = current.next
+        #     else:
+        #         self.now = current
+        #         return current
+        # self.now = current
+        return self.current.url
+
+
+browserHistory = BrowserHistory("google1.com")
+browserHistory.visit("google2.com")
+browserHistory.visit("google3.com")
+browserHistory.visit("google4.com")
+browserHistory.visit("google5.com")
+browserHistory.visit("google6.com")
+browserHistory.visit("google7.com")
+browserHistory.visit("google8.com")
+browserHistory.visit("google9.com")
+browserHistory.visit("google10.com")
+print(browserHistory.back(8))
+print(browserHistory.forward(4))
+browserHistory.visit("google11.com")
+browserHistory.visit("google12.com")
+print(browserHistory.back(4))
+print(browserHistory.forward(1))
+print(browserHistory.forward(2))
+print(browserHistory.forward(3))
+print(browserHistory.forward(4))

algorithm/List/linked_list_make_LinkedList.py

@@ -0,0 +1,73 @@
+"""
+Linked List 구현
+"""
+
+
+class Node:
+    def __init__(self, value=0, next=None):
+        self.value = value
+        self.next = next
+
+
+# first = Node(1)
+# second = Node(2)
+# third = Node(3)
+# first.next = second
+# second.next = third
+# first.value = 6
+
+
+class LinkedList(object):
+    def __init__(self):
+        self.head = None
+        self.tail = None
+
+    def append(self, value):
+        new_node = Node(value)
+        if self.head is None:
+            self.head = new_node
+        else:
+            current = self.head
+            while current.next:
+                current = current.next
+            current.next = new_node
+
+    def append_tail(self, value):
+        new_node = Node(value)
+        if self.head is None:
+            self.head = new_node
+            self.tail = new_node
+        else:
+            self.tail.next = new_node
+            self.tail = self.tail.next
+
+    def get(self, idx):
+        current = self.head
+        for _ in range(idx):
+            current = current.next
+        return current.value
+
+    def insert(self, idx, value):
+        current = self.head
+        new_node = Node(value)
+        for _ in range(idx - 1):
+            current = current.next
+        new_node.next = current.next
+        current.next = new_node
+
+    def remove(self, idx):
+        current = self.head
+        for _ in range(idx - 1):
+            current = current.next
+        current.next = current.next.next
+
+
+ll = LinkedList()
+ll.append(1)
+ll.append(2)
+ll.append(3)
+ll.append(4)
+ll.insert(2, 9)
+print(ll.get(0), ll.get(1), ll.get(2), ll.get(3))
+ll.remove(1)
+print(ll.get(0), ll.get(1), ll.get(2), ll.get(3))

algorithm/List/linked_list_palindrome.py

@@ -0,0 +1,56 @@
+"""
+link: https://leetcode.com/problems/palindrome-linked-list/
+파이썬 알고리즘 인터뷰 풀이 참고
+    런너 기법
+    - 연결 리스트를 순회할 때 2개의 포인터를 동시에 사용하는 기법
+    - 한 포인터가 다른 포인터보다 앞서게 하여 병합 지점이나 중간 위치, 길이 등을 판별할 때 유용하게 사용할 수 있다. 
+    - 중간 위치를 찾아내면, 값을 비교하거나 뒤집기를 시도하는 등 활용도가 높다. 
+
+"""
+import collections
+from typing import Deque
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+class Solution:
+    # 런너를 이용한 풀이
+    def is_palindrome(self, head: ListNode) -> bool:
+        rev = None
+        slow = fast = head
+
+        # 런너를 이용해 역순 리스트를 만든다.
+        # fast 가 두 칸씩 끝까지 가는 동안, slow는 한 칸씩 중간까지 가면서 역순 리스트(rev)를 만든다.
+        while fast and fast.next:
+            fast = fast.next.next
+            rev, rev.next, slow = slow, rev, slow.next
+        # list node 가 홀수개 일 때, slow를 한 칸 옮겨서 가운데 node를 pass한다.
+        # fast는 마지막 노드에 있고 fast.next는 None인 것을 이용한다.
+        if fast:
+            slow = slow.next
+
+        # 팰린드롬 여부 확인
+        while rev and rev.val == slow.val:
+            slow, rev = slow.next, rev.next
+        return not rev
+
+    # 데크를 이용한 풀이
+    def is_palindrome_deque(self, head: ListNode) -> bool:
+        q: Deque = collections.deque()
+
+        if not head:
+            return True
+
+        node = head
+        while node is not None:
+            q.append(node.val)
+            node = node.next
+
+        while len(q) > 1:
+            if q.popleft() != q.pop():
+                return False
+        return True

algorithm/QueueAndStack/heap_merge_k_sorted_lists.py

@@ -0,0 +1,29 @@
+from typing import List
+import heapq
+
+
+class ListNode:
+    def __init__(self, value, next):
+        self.value = value
+        self.next = next
+
+
+class Solution:
+    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
+        root = result = ListNode(None)
+        heap = []
+
+        # heap 에 모든 연결 리스트의 첫 Node(=루트)를 추가한다.
+        for i in range(len(lists)):
+            if lists[i]:
+                heapq.heappush(heap, (lists[i].val, i, lists[i]))
+
+        while heap:
+            node = heapq.heappop(heap)
+            idx = node[1]
+            result.next = node[2]
+
+            result = result.next
+            # linked list 에 다음 원소 있으면 heap에 추가
+            if result.next:
+                heapq.heappush(heap, (result.next.val, idx, result.next))

algorithm/QueueAndStack/queue_circular_queue.py

@@ -0,0 +1,24 @@
+class CircularQueue:
+    def __init__(self, k: int):
+        self.q = [None] * k
+        self.maxlen = k
+        self.p1 = 0
+        self.p2 = 0
+
+    # p2(rear) pointer 자리에 값 없는 것 확인 -> 값 추가하고 pointer은 다음으로 이동
+    def enQueue(self, value: int) -> bool:
+        if self.q[self.p2] is None:
+            self.q[self.p2] = value
+            self.p2 = (self.p2 + 1) % self.maxlen
+            return True
+        else:
+            return False
+
+    # p1(front) pointer 자리에 값 있으면 삭제하고 pointer 다음으로 이동
+    def deQueue(self) -> bool:
+        if self.q[self.p1] is None:
+            return False
+        else:
+            self.q[self.p1] = None
+            self.p1 = (self.p1 + 1) % self.maxlen
+            return True

algorithm/QueueAndStack/stack_daily_temperatures.py

@@ -0,0 +1,20 @@
+"""
+link: https://leetcode.com/problems/daily-temperatures/
+"""
+
+
+class Solution:
+    def dailyTemperatures(temperatures):
+        ans = [0] * len(temperatures)
+        stack = []
+        for cur_day, cur_temp in enumerate(temperatures):
+            while stack and stack[-1][1] < cur_temp:
+                prev_day, _ = stack.pop()
+                ans[prev_day] = cur_day - prev_day
+            stack.append((cur_day, cur_temp))
+        return ans
+
+
+# TEST
+S = Solution
+print(S.dailyTemperatures([73, 74, 75, 71, 69, 72, 76, 73]) == [1, 1, 4, 2, 1, 1, 0, 0])

algorithm/QueueAndStack/stack_valid_parentheses.py

@@ -0,0 +1,45 @@
+"""
+link : https://leetcode.com/problems/valid-parentheses/
+"""
+
+
+class Solution:
+    def valid_parentheses(s):
+        stack = []
+        pair = {"(": ")", "{": "}", "[": "]"}
+        for e in s:
+            if e in ["(", "{", "["]:
+                stack.append(e)
+            else:
+                if stack.pop() != pair[e]:
+                    return False
+
+            # if len(stack) == 0:
+            #     return True
+            # else:
+            #     return False
+            return True if len(stack) == 0 else False
+
+    # 다른 코드
+    def is_valid(s):
+        stack = []
+        for p in s:
+            if p == "(":
+                stack.append(")")
+            elif p == "[":
+                stack.append("]")
+            elif p == "{":
+                stack.append("}")
+            elif not stack or stack.pop() != p:
+                return False
+        # return not stack 으로 쓰면 1줄로 줄일 수 있음
+        return not stack
+
+
+# TEST
+S = Solution()
+print(S.is_valid("{({[]})}[]()") is True)
+print(S.is_valid("{({[])}[]()") is False)
+# print(S.valid_parentheses("{({[]})}[]()"))
+# print(S.valid_parentheses("{({[]})}[]()") is True)
+# print(S.valid_parentheses("{({[])}[]()") is False)

algorithm/Tree/tree_bfs.py

@@ -0,0 +1,19 @@
+from typings import List
+from collections import deque
+
+
+def bfs(root) -> List:
+    visited = []
+    if root is None:
+        return 0
+    q = deque()
+    q.append(root)
+    while q:
+        cur_node = q.popleft()
+        visited.append(cur_node.value)
+
+        if cur_node.left:
+            q.append(cur_node.left)
+        if cur_node.right:
+            q.append(cur_node.right)
+    return visited

algorithm/Tree/tree_dfs.py

@@ -0,0 +1,8 @@
+def dfs(root):
+    if root is None:
+        return
+    dfs(root.left)
+    dfs(root.right)
+
+
+# dfs(root)

algorithm/Tree/tree_level_order_maximum_depth.py

@@ -0,0 +1,53 @@
+"""
+link : https://leetcode.com/problems/maximum-depth-of-binary-tree/
+"""
+from collections import deque
+from typing import Optional
+
+
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+def array2tree(arr):
+    q = deque()
+    root = TreeNode(arr[0])
+    q.append(root)
+
+    idx = 1
+    while idx < len(arr):
+        cur_node = q.popleft()
+
+        # left Node
+        if arr[idx] is not None:
+            cur_node.left = TreeNode(arr[idx])
+            q.append(cur_node.left)
+        idx += 1
+
+        # right Node
+        if arr[idx] is not None:
+            cur_node.right = TreeNode(arr[idx])
+            q.append(cur_node.right)
+        idx += 1
+    return root
+
+
+class Solution:
+    def max_depth(self, root: Optional[TreeNode]) -> int:
+        max_depth = 0
+        if root is None:
+            return max_depth
+        q = deque()
+        q.append((root, 1))
+        while q:
+            cur_node, cur_depth = q.popleft()
+            max_depth = cur_depth
+            if cur_node.left:
+                q.append((cur_node.left, cur_depth + 1))
+            if cur_node.right:
+                q.append((cur_node.right, cur_depth + 1))
+        pass

algorithm/Tree/tree_post_order_lowest_common_ancestor.py

@@ -0,0 +1,53 @@
+"""
+link : https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/
+"""
+from collections import deque
+
+
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0):
+        self.val = val
+        self.left = None
+        self.right = None
+
+
+def array2tree(arr):
+    q = deque()
+    root = TreeNode(arr[0])
+    q.append(root)
+
+    idx = 1
+    while idx < len(arr):
+        cur_node = q.popleft()
+
+        # left Node
+        if arr[idx] is not None:
+            cur_node.left = TreeNode(arr[idx])
+            q.append(cur_node.left)
+        idx += 1
+
+        # right Node
+        if arr[idx] is not None:
+            cur_node.right = TreeNode(arr[idx])
+            q.append(cur_node.right)
+        idx += 1
+    return root
+
+
+class Solution:
+    def lowest_common_ancestor(self, root, p, q):
+        if root is None:
+            return None
+        left = self.lowest_common_ancestor(root.left, p, q)
+        right = self.lowest_common_ancestor(root.right, p, q)
+        if root.val == p or root.val == q:
+            return root.val
+        elif left and right:
+            return root.val
+        return left or right
+
+
+S = Solution()
+root = array2tree([3, 5, 1, 6, 0, 8, 9, None, None, 7, 4])
+print(S.lowest_common_ancestor(root, 6, 4) == 5)