Merge branch 'DaleStudy:main' into main

Author: yolophg

CONTRIBUTING.md

@@ -49,8 +49,27 @@ $ git push origin main
 
 확인이 되었으면, `Create pull request`를 누르고, `Title`에 **본인의 디스코드 닉네임을 포함 시켜주고** `Create pull request` 버튼을 클릭합니다.
 
-그러면 디스코드에도 알림이 올겁니다.
+그러면 디스코드에도 알림이 올겁니다. `Pull Request`를 생성한 뒤, 우측 `Project`탭에서 `Iteration`설정을 현재 진행 주차에 맞춰주시기 바랍니다. 
 
-이제 본인이 작성한 솔루션을 리뷰 받을 수 있습니다. 리뷰가 `approved` 된다면 메인 저장소를 `Merge` 하실 수 있습니다.
+또한 `Draft PR` 기능을 활용해 한 번에 모든 솔루션을 제출하기보다 본인의 진행 상황을 주기적으로 업데이트할 수 있도록 합니다. 
+
+`Draft` 변환은 `Pull Request` 생성 후 우측 상단 `Still in progress?` 항목을 통해 변환할 수 있습니다.
+
+이제 본인이 작성한 솔루션을 리뷰받을 수 있습니다. 리뷰가 `approved` 된다면 메인 저장소에 `Merge` 하실 수 있습니다.
+
+Pull Request 설명란에 문제를 해결하면서 어려웠던 부분이나 도움이 필요한 부분에 대해 남겨주시면 다른 분들이 리뷰할 때 참고할 수 있어서 좋겠죠?
+
+Pull Request에 대한 모든 프로세스가 완료되었다면, 본인의 Pull Request는 Pull Request 하단 `Merge pull request` 버튼을 클릭하여 
+
+직접 `Merge` 진행하도록 합니다.
+
+## PR 답안 코드 리뷰법
+
+본인의 Pull Request 작성 완료 후, 본인 직후 Pull Request를 생성한 스터디원의 솔루션을 리뷰합니다. 예를들어,
+
+![예시](images/337985716-307fdf57-90a7-4ccb-ab03-99a2d96fdc39.png)
+
+위 형식으로 리뷰를 진행합니다. 리뷰 내용은 당시까지 제출 완료된 코드를 기반으로 갯수 제한 없이 자유롭게 작성해 주시되, 유익한 리뷰를 지향하도록 합니다. 
+
+본인에게 할당된 리뷰 외 다른 멤버에 대한 코드 리뷰도 언제나 환영합니다.
 
-Pull Request 설명란에 문제를 해결하면서 어려웠던 부분이나 도움이 필요한 부분에 대해서 남겨주시면 다른 분들이 리뷰할 때 참고할 수 있어서 좋겠죠?

binary-tree-level-order-traversal/samthekorean.py

@@ -0,0 +1,24 @@
+# TC : O(n)
+# SC : O(n)
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        q = collections.deque()
+        res = []
+        q.append(root)
+
+        while q:
+            level = []
+            qLen = len(q)
+
+            # traverse nodes in each level and append left and right subtree if node is None
+            for i in range(qLen):
+                node = q.popleft()
+                if node:
+                    level.append(node.val)
+                    # append the subtrees of q for the next level in advance
+                    q.append(node.left)
+                    q.append(node.right)
+            if level:
+                res.append(level)
+
+        return res

container-with-most-water/Leo.py

@@ -0,0 +1,19 @@
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        left = 0
+        right = len(height) - 1
+
+        maxWater = 0
+
+        while left <= right:
+            hori = right - left
+            vert = min(height[left], height[right])
+            maxWater = max(maxWater, hori * vert)
+
+            if height[left] < height[right]:
+                left += 1
+            else:
+                right -= 1
+
+        return maxWater
+        # TC: O(n) SC: O(1)

container-with-most-water/bky373.java

@@ -0,0 +1,26 @@
+/**
+ * https://leetcode.com/problems/container-with-most-water/solution/
+ *
+ * time: O(N)
+ * space: O(1)
+ */
+class Solution {
+
+    public int maxArea(int[] height) {
+        int left = 0;
+        int right = height.length - 1;
+        int max = 0;
+        while (left < right) {
+            int area = (right - left) * Math.min(height[left], height[right]);
+            if (area > max) {
+                max = area;
+            }
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+        return max;
+    }
+}

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

@@ -0,0 +1,16 @@
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+
+        l = 0
+        r = len(nums) - 1
+
+        while l <= r:
+            mid = (l + r) // 2
+            if nums[mid] < nums[r]:
+                r = mid
+            else:
+                l = mid + 1
+
+        return nums[r]
+
+        # TC: O(logn), SC: O(1)

find-minimum-in-rotated-sorted-array/bky373.java

@@ -0,0 +1,22 @@
+/**
+ * https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
+ *
+ * time: O(log N)
+ * space: O(1)
+ */
+class Solution {
+
+    public int findMin(int[] nums) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (nums[left] > nums[right]) {
+            int mid = (left + right) / 2;
+            if (nums[mid] < nums[right]) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return nums[left];
+    }
+}

images/337985716-307fdf57-90a7-4ccb-ab03-99a2d96fdc39.png

@@ -0,0 +1,24 @@
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        l = 0
+        c_frequency = {}
+        longest_str_len = 0
+
+        for r in range(len(s)):
+            if not s[r] in c_frequency:
+                c_frequency[s[r]] = 0
+            c_frequency[s[r]] += 1
+
+            cells_count = r - l + 1
+            if cells_count - max(c_frequency.values()) <= k:
+                longest_str_len = max(longest_str_len, cells_count)
+
+            else:
+                c_frequency[s[l]] -= 1
+                if not c_frequency[s[l]]:
+                    c_frequency.pop(s[l])
+                l += 1
+
+        return longest_str_len
+
+        ## TC: O(n), SC: O(1)

longest-repeating-character-replacement/Leo.py

@@ -0,0 +1,24 @@
+/**
+ * https://leetcode.com/problems/longest-substring-without-repeating-characters/
+ *
+ * time: O(N)
+ * space: O(1)
+ */
+class Solution {
+
+    public int characterReplacement(String s, int k) {
+        int[] alp = new int[26];
+        int start = 0;
+        int maxCnt = 0;
+        int maxLen = 0;
+        for (int end = 0; end < s.length(); end++) {
+            maxCnt = Math.max(maxCnt, ++alp[s.charAt(end) - 'A']);
+            while (end - start + 1 - maxCnt > k) {
+                alp[s.charAt(start) - 'A']--;
+                start++;
+            }
+            maxLen = Math.max(maxLen, end - start + 1);
+        }
+        return maxLen;
+    }
+}

longest-repeating-character-replacement/bky373.java

@@ -0,0 +1,15 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        left = 0
+        seen = {}
+        res = 0
+
+        for right, curr in enumerate(s):
+            if curr in seen:
+                left = max(left, seen[curr] + 1)
+            res = max(res, right - left + 1)
+            seen[curr] = right
+
+        return res
+
+        ## TC:O(n), SC:O(min(m,n)) where n is len(s) and m is size(seen)