Merge branch 'DaleStudy:main' into main

Author: gitsunmin

find-minimum-in-rotated-sorted-array/EGON.py

@@ -0,0 +1,43 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        return self.solve_binary_search(nums)
+
+    """
+    Runtime: 32 ms (Beats 97.56%)
+    Time Complexity: O(log n)
+        - 크기가 n인 배열에 대한 이분탐색에 O(log n)
+            - while 조건문 판단에 O(2), and 연산이므로 단축 평가에 의해 upper bound
+        - 엣지 케이스 처리를 위한 마지막 lo, hi 2개 항에 대한 min연산에 O(2)
+        > O(log n) * O(2) + O(2) ~= O(log n)
+
+    Memory: 16.82 (Beats 50.00%)
+    Space Complexity: O(1)
+        > 이분탐색에 필요한 정수형 변수 lo, hi, mid 3개만 사용했으므로 n과 상관없이 O(1)
+    """
+    def solve_binary_search(self, nums: List[int]) -> int:
+        lo, hi = 0, len(nums) - 1
+        while lo < hi and nums[hi] < nums[lo]:
+            mid = (lo + hi) // 2
+            if nums[lo] < nums[mid]:
+                lo = mid
+            elif nums[mid] < nums[hi]:
+                hi = mid
+            else:
+                break
+
+        return min(nums[lo], nums[hi])
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        nums = [2, 1]
+        output = 1
+        self.assertEqual(Solution().findMin(nums), output)
+
+
+if __name__ == '__main__':
+    main()

find-minimum-in-rotated-sorted-array/kayden.py

@@ -0,0 +1,14 @@
+class Solution:
+    # 시간복잡도: O(logN)
+    # 공간복잡도: O(1)
+    def findMin(self, nums: List[int]) -> int:
+        n = len(nums)
+        st, en = 0, n-1
+        while st < en:
+            mid = (st+en)//2
+            if nums[mid] > nums[en]:
+                st = mid + 1
+            else:
+                en = mid
+
+        return nums[st]

find-minimum-in-rotated-sorted-array/mangodm-web.py

@@ -0,0 +1,24 @@
+from typing import List
+
+
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        """
+        - Idea: 회전된 정렬 배열에서 가장 작은 값을 찾기 위해 두 개의 포인터, left, right를 이용한다.
+            두 개의 포인터는 조건에 따라 배열에서 탐색할 범위를 줄여가는데 활용된다.
+        - Time Complexity: O(logn). n은 배열의 크기이다.
+            매번 배열을 절반으로 나눠서 탐색 범위를 줄이기 때문에 O(logn) 시간이 걸린다.
+        - Space Complexity: O(1). 배열의 크기와 상관없이 left, right, mid 변수만 사용되므로
+            상수 공간만 차지한다.
+        """
+        left, right = 0, len(nums) - 1
+
+        while left < right:
+            mid = (left + right) // 2
+
+            if nums[right] < nums[mid]:
+                left = mid + 1
+            else:
+                right = mid
+
+        return nums[left]

find-minimum-in-rotated-sorted-array/sunjae95.js

@@ -0,0 +1,32 @@
+/**
+ * @description
+ * brainstorming:
+ * brute force
+ *
+ * n = length of head
+ * time complexity: O(n)
+ * space complexity: O(1)
+ */
+var findMin = function (nums) {
+  let answer = 5000;
+  nums.forEach((num) => (answer = Math.min(answer, num)));
+
+  return answer;
+};
+
+/* n = length of head
+ * time complexity: O(n)
+ * space complexity: O(1)
+ */
+var findMin = function (nums) {
+  let answer = nums[0];
+  if (nums.length === 1) return answer;
+  if (answer < nums[nums.length - 1]) return answer;
+
+  for (let i = nums.length - 1; i >= 0; i--) {
+    if (answer < nums[i]) return answer;
+    answer = nums[i];
+  }
+
+  return answer;
+};

linked-list-cycle/EGON.py

@@ -0,0 +1,47 @@
+from typing import Optional
+from unittest import TestCase, main
+
+
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        return self.solve(head)
+
+    """
+    Runtime: 37 ms (Beats 93.02%)
+    Time Complexity: O(n)
+        > head부터 next가 있는 동안 선형적으로 조회하므로 O(n)
+
+    Memory: 18.62 (Beats 98.22%)
+    Space Complexity: O(1)
+        > head를 제외하고 아무 변수도 사용하지 않았으므로 O(1)
+    """
+    def solve(self, head: Optional[ListNode]) -> bool:
+        if not head:
+            return False
+
+        while head.next:
+            if head.next and head.next.val is None:
+                return True
+
+            head.val = None
+            head = head.next
+
+        return False
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        head = None
+        output = False
+        self.assertEqual(Solution().hasCycle(head), output)
+
+
+if __name__ == '__main__':
+    main()

linked-list-cycle/kayden.py

@@ -0,0 +1,14 @@
+class Solution:
+    # 시간복잡도: O(N)
+    # 공간복잡도: O(N)
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+
+        visited = set()
+        while head:
+            if head in visited:
+                return True
+
+            visited.add(head)
+            head = head.next
+
+        return False

linked-list-cycle/mangodm-web.py

@@ -0,0 +1,33 @@
+from typing import Optional
+
+
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, x: int) -> None:
+        self.val = x
+        self.next = None
+
+
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        """
+        - Idea: 사이클이 있는 연결 리스트인지 판단하기 위해 두 개의 포인터, slow와 fast를 사용한다.
+            slow 포인터는 한번에 한 칸씩, fast 포인터는 한번에 두 칸씩 이동한다.
+            만약 두 포인터가 만나면, 리스트에 사이클이 존재한다고 판단할 수 있다.
+            fast가 리스트의 끝에 도달한다면 사이클이 없다고 판단한다.
+        - Time Complexity: O(n). n은 리스트에 포함된 노드의 개수다.
+            사이클이 없는 경우, fast 포인터는 리스트 끝까지 이동한다.
+            사이클이 있는 경우, 두 포인터가 만날 때까지 이동하므로 O(n)의 시간이 소요된다.
+        - Space Complexity: O(1). 연결 리스트의 크기와 상관없이 slow와 fast 변수만 사용되므로
+            상수 공간만 차지한다.
+        """
+        slow, fast = head, head
+
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+
+            if slow == fast:
+                return True
+
+        return False

linked-list-cycle/sunjae95.js

@@ -0,0 +1,21 @@
+/**
+ * @description
+ * brainstorming:
+ * hash table
+ *
+ * n = length of head
+ * time complexity: O(n)
+ * space complexity: O(n)
+ */
+var hasCycle = function (head) {
+  const set = new Set();
+  let node = head;
+
+  while (node) {
+    if (set.has(node)) return true;
+    set.add(node);
+    node = node.next;
+  }
+
+  return false;
+};

maximum-product-subarray/EGON.py

@@ -0,0 +1,67 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+    def maxProduct(self, nums: List[int]) -> int:
+        return self.solveWithDP(nums)
+
+    """
+    Runtime: 71 ms (Beats 61.13%)
+    Time Complexity: O(n)
+        - dp 배열 초기화를 위한 nums.copy()에 O(n)
+        - range(1, L) 조회하며 조건에 따라 연산에 O(n - 1)
+        - range(L) 조회하며 max 계산에 O(n)
+        > O(n) + O(n - 1) + O(n) ~= O(n)
+
+    Memory: 17.75 MB (Beats 11.09%)
+    Space Complexity: O(n)
+        - 크기가 n인 배열 2개 사용했으므로 2 * O(n)
+        > O(2n) ~= O(n)
+    """
+    def solveWithDP(self, nums: List[int]) -> int:
+        L = len(nums)
+        forward_product, backward_product = nums.copy(), nums.copy()
+        for i in range(1, L):
+            if forward_product[i - 1] != 0:
+                forward_product[i] *= forward_product[i - 1]
+
+            if backward_product[L - i] != 0:
+                backward_product[L - i - 1] *= backward_product[L - i]
+
+        result = nums[0]
+        for i in range(L):
+            result = max(result, forward_product[i], backward_product[i])
+
+        return result
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        nums = [2,3,-2,4]
+        output = 6
+        self.assertEqual(Solution.maxProduct(Solution(), nums), output)
+
+    def test_2(self):
+        nums = [-2,0,-1]
+        output = 0
+        self.assertEqual(Solution.maxProduct(Solution(), nums), output)
+
+    def test_3(self):
+        nums = [-2]
+        output = -2
+        self.assertEqual(Solution.maxProduct(Solution(), nums), output)
+
+    def test_4(self):
+        nums = [0,-3,-2,-3,-2,2,-3,0,1,-1]
+        output = 72
+        self.assertEqual(Solution.maxProduct(Solution(), nums), output)
+
+    def test_5(self):
+        nums = [7, -2, -4]
+        output = 56
+        self.assertEqual(Solution.maxProduct(Solution(), nums), output)
+
+
+if __name__ == '__main__':
+    main()