Merge branch 'DaleStudy:main' into main

Author: Real-Reason

best-time-to-buy-and-sell-stock/thispath98.py

@@ -0,0 +1,12 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        minimum = prices[0]
+        answer = 0
+        for i in range(1, len(prices)):
+            if minimum > prices[i]:
+                minimum = prices[i]
+            else:
+                diff = prices[i] - minimum
+                if answer < diff:
+                    answer = diff
+        return answer

container-with-most-water/Chaedie.py

@@ -0,0 +1,43 @@
+"""
+Solution: Brute Force
+Time: O(n^2)
+Space: O(1)
+"""
+
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        max_water = 0
+        for i in range(len(height) - 1):
+            for j in range(i + 1, len(height)):
+                h = min(height[i], height[j])
+                w = j - i
+                max_water = max(h * w, max_water)
+
+        return max_water
+
+
+"""
+Solution: Two Pointer
+    1) 포인터 이동은 left height, right height 중 작은 value를 가질 경우 이동
+Time: O(n)
+Space: O(1)
+"""
+
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        l = 0
+        r = len(height) - 1
+        max_water = 0
+
+        while l < r:
+            h = min(height[l], height[r])
+            w = r - l
+            max_water = max(h * w, max_water)
+
+            if height[l] < height[r]:
+                l += 1
+            else:
+                r -= 1
+        return max_water

container-with-most-water/EcoFriendlyAppleSu.kt

@@ -0,0 +1,59 @@
+package leetcode_study
+
+/*
+* 주어진 높이에서 만들 수 있는 가장 큰 면적을 구하는 문제.
+* Brute force로 모든 경우의 수를 따져가며 최대 면적을 구하는 방법.
+* 주어진 높이(n)의 개수는 2 보다 크거가 같고 10^4 보다 작거나 같음.
+* 이중 Loop으로 해결할 경우 시간 초과 발생 (10^8 이하로 해결해야 제한 시간 안으로 문제 해결 가능)
+*
+* 시간 복잡도: O(n^2)
+* -> 두 개의 서로 다른 높이를 구하기 위해 이중 반복문 실행: O(n^2)
+* 공간 복잡도: O(1)
+* -> 추가 메모리 사용 없음.
+* */
+fun maxArea01(height: IntArray): Int {
+    var maxValue = 0
+    for (i in 0 until height.size) {
+        for (j in i + 1 until height.size) {
+            // 너비는 두 선분 사이의 거리
+            val width = j - i
+            // 높이는 두 선분 중 작은 값
+            val containerHeight = Math.min(height[i], height[j])
+            // 면적 계산
+            val area = width * containerHeight
+            // 최대값 갱신
+            maxValue = Math.max(maxValue, area)
+        }
+    }
+    return maxValue
+}
+
+/*
+* 이중 포인터를 사용한 문제 풀이.
+* 결과에 영향을 주는 조건과 요소
+* -> 높이의 위치를 나타내는 왼쪽값과 오른쪽 값에서 두 값 중 작은 값이 높이가 될 수 있음.
+* -> 오른쪽의 값은 왼쪽 값보다 작을 수 없음.
+* -> 너비 값은 오른쪽 인덱스에서 왼쪽 인덱스를 뺀 값임.
+*
+* 시간 복잡도: O(n)
+* -> 주어진 높이 배열에서 양쪽 끝 값을 증감/가감 해가며 반복 진행: O(n)
+* 공간 복잡도: O(1)
+* -> 추가 메모리 사용 없음.
+* */
+fun maxArea02(height: IntArray): Int {
+    var maxValue = 0
+    var left = 0
+    var right = height.size - 1
+    while (left <= right) {
+        val width = right - left
+        val containerHeight = Math.min(height[left], height[right])
+        val area = width * containerHeight
+        maxValue = Math.max(maxValue, area)
+        if (height[left] < height[right]) {
+            left++
+        } else {
+            right--
+        }
+    }
+    return maxValue
+}

container-with-most-water/GangBean.java

@@ -0,0 +1,45 @@
+class Solution {
+    public int maxArea(int[] height) {
+        /**
+        1. understanding
+        - with two pair of line, each can contain "min(line1,line2) * (distance)" mount of water
+        - find maximum amount of water can contain
+        2. strategy
+        - brute force
+            - for each pair of lines, calculate amount and update maximum amount.
+            - it can takes O(N), where N is the count of lines.
+            - N is 10^5 at most, so it can takes 10^10, which can takes about 10 seconds
+        - you need to swap out unnecessary calculation
+        - so, let's find a unnecessary calculation in this problem.
+        3. complexity
+        - time: O(N)
+        - space: O(1)
+        */
+        int l = 0;
+        int r = height.length - 1;
+        int maxAmount = amountOf(height, l, r); // Math.min(height[l], height[r], r-l);
+        while (l < r) { // O(N)
+            maxAmount = Math.max(maxAmount, amountOf(height, l, r));
+            if (height[l] < height[r]) {
+                l++;
+            } else if (height[l] > height[r]) {
+                r--;
+            } else {
+                int nextLeftAmount = amountOf(height, l+1, r);
+                int nextRightAmount = amountOf(height, l, r-1);
+                if (nextLeftAmount < nextRightAmount) {
+                    r--;
+                } else {
+                    l++;
+                }
+            }
+        }
+
+        return maxAmount;
+    }
+
+    private int amountOf(int[] height, int left, int right) {
+        return (Math.min(height[left], height[right]) * (right - left));
+    }
+}
+

container-with-most-water/HerrineKim.js

@@ -0,0 +1,26 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)
+
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var maxArea = function (height) {
+  let maxWater = 0;
+  let left = 0;
+  let right = height.length - 1;
+
+  while (left < right) {
+    const lowerHeight = Math.min(height[left], height[right]);
+    const width = right - left;
+    maxWater = Math.max(maxWater, lowerHeight * width);
+
+    if (height[left] < height[right]) {
+      left++;
+    } else {
+      right--;
+    }
+  }
+
+  return maxWater;
+};

container-with-most-water/HodaeSsi.py

@@ -0,0 +1,17 @@
+# 시간 복잡도 : O(n)
+# 공간 복잡도 : O(1)
+# 문제 유형 : Two Pointer
+class Solution:
+	def maxArea(self, height: List[int]) -> int:
+		left, right = 0, len(height) - 1
+		max_area = 0
+		
+		while left < right:
+			max_area = max(max_area, (right - left) * min(height[left], height[right]))
+			if height[left] < height[right]:
+				left += 1
+			else:
+				right -= 1
+		
+		return max_area
+

container-with-most-water/Jay-Mo-99.py

@@ -0,0 +1,40 @@
+        #해석
+        #s는 start index, e는 ending index로 할당한다. 
+        #area 에 (e-s)*min(height[e], height[s]) 로 면적의 넓이를 구한다.
+        #만약 height[s]가 height[e] 보다 작다면, 현 area보다 더 큰 결괏값을 위해 변화를 준다. 
+        #   (e-s)에서 e를 줄어들면 필연적으로 area 값이 기존보다 적어진다. 따라서 s에 1을 더해 인덱스를 오른쪽으로 이동시켜 height[s] 에 변화를 준다. 
+        #그 외의 상황에는 height[e]를 변화시키기 위해 e에 1를 빼 왼쪽 인덱스로 이동시킨다.  
+        #해당 루프는 s가 e보다 작을때 작용된다. 만약 s의 증가와 e의 감소로 두 변수가 마주치면 종료한 후 max_area를 return시킨다. 
+       
+
+
+        #Big O
+        #- N: height의 element 갯수
+
+        #Time Complexity: O(N) 
+        #- while : s와 e가 만날때까지 최대 N번 반복된다. 각 반복에서의 연산들은 O(1)에 해당된다. -> O(N)
+        
+
+        #Space Complexity: O(1)
+        #- s,e,max_area: 변수는 상수로 작용된다 -> O(1)
+        ####
+        #
+        #
+class Solution(object):
+    def maxArea(self, height):
+        """
+        :type height: List[int]
+        :rtype: int
+        """
+        max_area = 0 #Saving for answer
+        s,e=0,len(height)-1 #Assign the first index and last index
+        while s<e:
+            area = (e-s) * min(height[s],height[e]) #Current area using e,s
+            max_area = max(area, max_area) #Re-assing the max_area comparing with area
+            if height[s]< height[e]:
+                s+=1
+            else:
+                e -=1
+        return max_area
+
+

container-with-most-water/Jeehay28.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+var maxArea = function (height) {
+  let start = 0;
+  let end = height.length - 1;
+  let maxArea = 0;
+
+  while (start < end) {
+    const area = (end - start) * Math.min(height[start], height[end]);
+    maxArea = Math.max(area, maxArea);
+
+    // The shorter height limits the area.
+    // By moving the pointer associated with the shorter height,
+    // the algorithm maximizes the chance of finding a taller line that can increase the area.
+    // This is the essence of the two-pointer strategy for the container problem.
+    if (height[start] < height[end]) {
+      start += 1;
+    } else {
+      end -= 1;
+    }
+  }
+  return maxArea;
+};
+

container-with-most-water/KwonNayeon.py

@@ -0,0 +1,12 @@
+"""
+Constraints:
+1. n == height.length
+2. 2 <= n <= 10^5
+3. 0 <= height[i] <= 10^4
+
+Time Complexity: 
+- 
+
+Space Complexity: 
+- 
+"""

container-with-most-water/YeomChaeeun.ts

@@ -0,0 +1,33 @@
+/**
+ * 배열의 두개의 높이를 가지고 최대 용량을 구하기
+ * 알고리즘 복잡도
+ * - 시간 복잡도: O(n)
+ * - 공간 복잡도: O(1)
+ * @param height
+ */
+function maxArea(height: number[]): number {
+    // end - start * min(height[start], height[end])가 큰 것
+
+    // 8 - 0 * min(1, 7) = 8
+    // 8 - 1 * min(8, 7) = 49
+    // 7 - 1 * min(8, 3) = 18
+    // 6 - 1 * min(8, 8) = 40
+    // ...
+
+    let s = 0
+    let e = height.length - 1
+    let curr = 0
+    let max = 0
+
+    while(s < e) {
+        curr = (e - s) * Math.min(height[s], height[e])
+        max = Math.max(curr, max)
+        if(height[s] < height[e]){
+            s += 1
+        } else {
+            e -= 1
+        }
+    }
+
+    return max
+}

container-with-most-water/Yjason-K.ts

@@ -0,0 +1,34 @@
+/**
+ * 계산할 수 있는 면적에서 가장 큰 면적 구하기.
+ * 
+ * @param {number[]} height - x 축 방향의 높이 배열 
+ * @returns {number} - 가장 넓은 면적 반환
+ * 
+ * 시간 복잡도 O(n)
+ * - n은 height 배열의 길이
+ * 
+ * 공간 복잡도 O(1) 
+ * - 포인터 및 결과값 저장 공간만 사용
+ */
+function maxArea(height: number[]): number {
+    let start = 0; // 시작 포인터 초기화
+    let end = height.length - 1; // 끝 포인터 초기화
+    let result = 0; // 최대 면적 저장
+
+    while (start < end) {
+        // 현재 면적 계산
+        const currentArea = Math.min(height[start], height[end]) * (end - start);
+        // 최대 면적 업데이트
+        result = Math.max(result, currentArea);
+
+        // 포인터 이동 (높이가 낮은 쪽을 이동)
+        if (height[start] > height[end]) {
+            end--;
+        } else {
+            start++;
+        }
+    }
+
+    return result;
+}
+

container-with-most-water/aa601.py

@@ -0,0 +1,15 @@
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        right = len(height) - 1
+        left = 0
+        max_size = 0
+        for line in range(len(height)):
+            if left >= right:
+                break
+            cur_size = (right - left) * min(height[left], height[right])
+            if height[left] < height[right]: # 왼쪽이 작으면 left 이동
+                left += 1
+            else:
+                right -= 1
+            max_size = max(max_size, cur_size)
+        return max_size