Merge branch 'DaleStudy:main' into main

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/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/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/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

container-with-most-water/higeuni.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ * 
+ * complexity
+ * time: O(n)
+ * space: O(1)
+ */
+
+var maxArea = function(height) {
+  let answer = 0;
+  let l = 0, r = height.length - 1;
+
+  while(l < r) {
+      const area = (r - l) * Math.min(height[l], height[r]);
+
+      answer = area > answer ? area : answer;
+
+      if(height[l] < height[r]) {
+          l += 1;
+      }else {
+          r -= 1;
+      }
+  }
+
+  return answer;
+};
+

container-with-most-water/imsosleepy.java

@@ -0,0 +1,19 @@
+// 투포인터를 활용한 시간복잡도 O(N)으로 풀면된다.
+// 중요한건 언제 이동하냐?를 정의하는건데, 전체 물양이 줄어들면 상대적으로 작은 쪽을 이동시키면된다.
+class Solution {
+    public int maxArea(int[] height) {
+        int left = 0;
+        int right = height.length-1;
+        int maxWater = 0;
+        while(left < right) {
+            int max = Math.min(height[left], height[right]) * (right - left);
+            maxWater = Math.max(max,maxWater);
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+        return maxWater;
+    }
+}

container-with-most-water/jeldo.py

@@ -0,0 +1,13 @@
+class Solution:
+    # O(n), n = len(height)
+    def maxArea(self, height: list[int]) -> int:
+        max_amount = 0
+        l, r = 0, len(height) - 1
+        while l < r:
+            amount = min(height[l], height[r]) * (r - l)
+            max_amount = max(max_amount, amount)
+            if height[l] < height[r]:
+                l += 1
+            else:
+                r -= 1
+        return max_amount

container-with-most-water/lledellebell.ts

@@ -0,0 +1,41 @@
+/***
+ * 
+ * @problem
+ * - 배열에서 두 선을 선택하여 최대 물을 담을 수 있는 면적을 구하는 문제
+ * 
+ * @constraints
+ * - 배열의 길이는 2 이상 10^5 이하입니다.
+ * - 각 높이는 0 이상 10^4 이하의 정수입니다.
+ * 
+ * @example
+ * - 입력: height = [1,8,6,2,5,4,8,3,7]
+ * - 출력: 49
+ *   (높이 8과 7을 선택하여 넓이 = min(8, 7) * (8 - 1) = 49)
+ * 
+ * @description
+ * - 배열의 양 끝에서 시작하는 두 개의 포인터를 사용하여 문제를 해결합니다.
+ * - 현재 포인터 위치에서의 넓이를 계산하고 최대값을 갱신합니다.
+ * - 더 작은 높이를 가진 포인터를 이동하여 더 큰 넓이를 탐색합니다.
+ * 
+ * @complexity
+ * - 시간 복잡도: O(n)
+ *   (배열을 한 번만 순회하며 최대 넓이를 계산)
+ * - 공간 복잡도: O(1)
+ *   (추가 메모리 사용 없이 포인터만 사용)
+ * 
+ */
+function maxArea(height: number[]): number {
+    let left = 0, 
+        right = height.length - 1, 
+        maxArea = 0;
+
+    while (left < right) {
+        // 현재 넓이 계산 및 최대값 갱신
+        maxArea = Math.max(maxArea, Math.min(height[left], height[right]) * (right - left));
+
+        // 더 작은 높이의 포인터를 이동
+        height[left] < height[right] ? left++ : right--;
+    }
+
+    return maxArea;
+}

container-with-most-water/neverlish.go

@@ -0,0 +1,40 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)
+
+package main
+
+import "testing"
+
+func TestMaxArea(t *testing.T) {
+	result1 := maxArea([]int{1, 8, 6, 2, 5, 4, 8, 3, 7})
+
+	if result1 != 49 {
+		t.Errorf("Expected 49, but got %v", result1)
+	}
+
+	result2 := maxArea([]int{1, 1})
+
+	if result2 != 1 {
+		t.Errorf("Expected 1, but got %v", result2)
+	}
+}
+
+func maxArea(height []int) int {
+	result := 0
+
+	pointer_left := 0
+	pointer_right := len(height) - 1
+
+	for pointer_left < pointer_right {
+		area := (pointer_right - pointer_left) * min(height[pointer_left], height[pointer_right])
+		result = max(result, area)
+
+		if height[pointer_left] < height[pointer_right] {
+			pointer_left++
+		} else {
+			pointer_right--
+		}
+	}
+
+	return result
+}

container-with-most-water/pmjuu.py

@@ -0,0 +1,26 @@
+'''
+시간 복잡도: O(n)
+- 두 포인터를 이동하면서 배열을 한 번만 순회하므로 시간 복잡도는 O(n)입니다.
+
+공간 복잡도: O(1)
+- 추가 메모리를 사용하지 않고 변수만 사용하므로 O(1)입니다.
+'''
+
+from typing import List
+
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        max_area = 0
+        left, right = 0, len(height) - 1
+
+        while left < right:
+            current_area = (right - left) * min(height[left], height[right])
+            max_area = max(current_area, max_area)
+
+            if height[left] < height[right]:
+                left += 1
+            else:
+                right -= 1
+
+        return max_area

container-with-most-water/sungjinwi.py

@@ -0,0 +1,26 @@
+"""
+	풀이 :
+		left, right 커서를 양 끝에 놓고 조건에 따라 반대편으로 이동시키며 물 양 비교
+		둘 중 더 높은 높이를 이동시키면 무조건 물의 양이 줄어들기 때문에 더 낮거나 같은 커서를 이동시키며 업데이트
+		둘이 만나면 비교 종료
+
+
+	len(height) : N
+	TC : O(N)
+		l, r의 이동이 전체 height 개수만큼 일어나므로
+	SC : O(1)
+"""
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        l = 0
+        r = len(height) - 1
+        max_area = 0
+        while (l != r) :
+            cur_area = (r - l) * min(height[l], height[r])
+            max_area =  max(cur_area, max_area)
+            if (height[l] >= height[r]) :
+                r -= 1
+            else :
+                l += 1
+        return max_area