[Leo] 6th Week solutions + CONTRIBUTING.md update

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 설명란에 문제를 해결하면서 어려웠던 부분이나 도움이 필요한 부분에 대해서 남겨주시면 다른 분들이 리뷰할 때 참고할 수 있어서 좋겠죠?

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)

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)

longest-repeating-character-replacement/Leo.py

@@ -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-substring-without-repeating-characters/Leo.py

@@ -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)

search-in-rotated-sorted-array/Leo.py

@@ -0,0 +1,33 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        left, right = 0, len(nums) - 1
+
+        while left <= right:
+            mid = (left + right) // 2
+
+            if nums[mid] == target:
+                return mid
+
+            if nums[left] <= nums[mid]:
+                if nums[left] <= target < nums[mid]:
+                    right = mid - 1
+                else:
+                    left = mid + 1
+
+            else:
+                if nums[mid] < target <= nums[right]:
+                    left = mid + 1
+                else:
+                    right = mid - 1
+
+        return -1
+
+        ## TC: O(n), SC: O(1)
+
+        # if target in nums:
+        #     return nums.index(target)
+        # else:
+        #     return -1
+
+        ## TC: O(n), this may fater than bintree way if gvien nums are longer
+        ## SC: O(n)