Merge branch 'DaleStudy:main' into main

Author: devyejin

container-with-most-water/delight010.swift

@@ -0,0 +1,22 @@
+class Solution {
+    func maxArea(_ height: [Int]) -> Int {
+        var maxArea = 0
+        var startPointIndex = 0
+        var endPointIndex = height.count - 1
+        while startPointIndex < endPointIndex {
+            let minHeight = min(height[startPointIndex], height[endPointIndex])
+            let area = minHeight * (endPointIndex - startPointIndex)
+            maxArea = max(maxArea, area)
+            if height[startPointIndex] < height[endPointIndex] {
+                startPointIndex += 1
+            } else {
+                endPointIndex -= 1
+            }
+        }
+        return maxArea
+    }
+}
+
+// Time Complexity O(N)
+// Space Complexity O(1)
+ 

container-with-most-water/hoyeongkwak.java

@@ -0,0 +1,22 @@
+/*
+Time Complexity : O(n)
+Space Complexity : O(1)
+*/
+class Solution {
+    public int maxArea(int[] height) {
+        int left = 0;
+        int right = height.length - 1;
+        int area = 0;
+
+        while (left < right) {
+            int currentArea = (right - left) * Math.min(height[left], height[right]);
+            area = Math.max(area, currentArea);
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+        return area;
+    }
+}

container-with-most-water/hu6r1s.py

@@ -0,0 +1,20 @@
+
+class Solution:
+    """
+    1. 브루트포스와 같이 전부 길이를 대조해보고 하면 시간복잡도가 터질 것.
+    투포인터 방식을 활용하면 됨. 투포인터에 대한 문제가 코딩테스트로 많이 나올 것 같음.
+    확실하게 공부 필요.
+    """
+    def maxArea(self, height: List[int]) -> int:
+        max_area = 0
+        start, end = 0, len(height) - 1
+        while start < end:
+            area = (end - start) * min(height[start], height[end])
+            max_area = max(area, max_area)
+
+            if height[start] <= height[end]:
+                start += 1
+            else:
+                end -= 1
+
+        return max_area

container-with-most-water/hyer0705.ts

@@ -0,0 +1,21 @@
+function maxArea(height: number[]): number {
+  const n = height.length;
+
+  let maximumArea = 0;
+  let l = 0;
+  let r = n - 1;
+
+  while (l < r) {
+    const currentArea = (r - l) * Math.min(height[l], height[r]);
+
+    maximumArea = Math.max(maximumArea, currentArea);
+
+    if (height[l] > height[r]) {
+      r--;
+    } else {
+      l++;
+    }
+  }
+
+  return maximumArea;
+}

container-with-most-water/hyunjung-choi.kt

@@ -0,0 +1,22 @@
+/**
+ * 시간 복잡도: O(n)
+ * 공간 복잡도: O(1)
+ */
+
+class Solution {
+    fun maxArea(height: IntArray): Int {
+        var i = 0
+        var j = height.size - 1
+        var max = 0
+
+        while (i < j) {
+            val h = minOf(height[i], height[j])
+            max = maxOf(max, (j - i) * h)
+
+            if (height[i] <= height[j]) i++
+            else j--
+        }
+
+        return max
+    }
+}

container-with-most-water/jinvicky.java

@@ -0,0 +1,26 @@
+/**
+ * 구하려는 것은 최대 영역값이기 때문에 x,y축을 계산한 현재 영역과 기존 영역을 비교해 max값을 반환하면 됩니다.
+ * 포인터를 어떻게 좁힐까 생각할 수 있는데 쉽게 말해서 start와 end 중 더 작은 쪽을 앞 또는 뒤로 이동하면 됩니다.
+ * 영역은 두 막대가 모두 충족가능한 길이가 되어야 하므로 Math.min()으로 설정합니다.
+ */
+class Solution {
+    public int maxArea(int[] height) {
+        int start = 0;
+        int end = height.length - 1;
+        int area = 0;
+
+        while (start < end) {
+            int y = Math.min(height[start], height[end]); // y축은 더 작은 값으로 설정
+            int x = Math.abs(start - end); // end - start도 가능
+            int calculatedArea = x * y;
+            area = Math.max(area, calculatedArea);
+
+            // [중요] 포인터 이동 로직
+            if (height[start] <= height[end])
+                start++;
+            else
+                end--;
+        }
+        return area;
+    }
+}

container-with-most-water/jun0811.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var maxArea = function (height) {
+  // 더 낮은 쪽을 안쪽으로 이동하는 방식으로
+
+  let start = 0;
+  let end = height.length - 1;
+  let res = -1;
+  while (start <= end) {
+    const v = Math.min(height[start], height[end]) * (end - start);
+    if (v > res) {
+      res = v;
+    }
+
+    if (height[start] > height[end]) {
+      end -= 1;
+    } else {
+      start += 1;
+    }
+  }
+  return res;
+};

container-with-most-water/njngwn.java

@@ -0,0 +1,28 @@
+// Time Complexity: O(n), n: height.length
+// Space Complexity: O(1)
+class Solution {
+    public int maxArea(int[] height) {
+        int maxWaterAmount = 0;
+        int leftLineIdx = 0;
+        int rightLineIdx = height.length-1;
+
+        while (leftLineIdx < rightLineIdx) {
+            int leftHeight = height[leftLineIdx];
+            int rightHeight = height[rightLineIdx];
+            int tempAmount = 0;
+
+            if (leftHeight < rightHeight) {
+                tempAmount = leftHeight * (rightLineIdx - leftLineIdx);
+                leftLineIdx++;
+            } else {
+                tempAmount = rightHeight * (rightLineIdx - leftLineIdx);
+                rightLineIdx--;
+            }
+
+            // update maximum amount
+            maxWaterAmount = tempAmount > maxWaterAmount ? tempAmount : maxWaterAmount;
+        }
+
+        return maxWaterAmount;
+    }
+}

container-with-most-water/s0ooo0k.java

@@ -0,0 +1,21 @@
+class Solution {
+    public int maxArea(int[] height) {
+        int left=0;
+        int right=height.length-1;
+        int max=0;
+
+        while(left<right) {
+            int water = (right-left) * Math.min(height[left], height[right]);
+            max = Math.max(max, water);
+
+            if(height[left]<height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+        return max;
+    }
+}
+
+

container-with-most-water/sonjh1217.swift

@@ -0,0 +1,27 @@
+class Solution {
+    func maxArea(_ height: [Int]) -> Int {
+        var heights = height
+        var start = 0
+        var end = heights.count - 1
+        var maxAmount = 0
+
+        while start < end {
+            let startHeight = heights[start]
+            let endHeight = heights[end]
+            let amount = min(startHeight, endHeight) * (end - start)
+            maxAmount = max(amount, maxAmount)
+
+            if startHeight < endHeight {
+                start += 1
+            } else {
+                end -= 1
+            }
+        }
+
+        return maxAmount
+
+        //시간 O(n)
+        //공간 O(1)
+    }
+}
+