Merge branch 'main' of https://github.com/sukyoungshin/leetcode-study

Author: sukyoungshin

3sum/KwonNayeon.py

@@ -3,14 +3,35 @@
 1. 3 <= nums.length <= 3000
 2. -10^5 <= nums[i] <= 10^5
 
-Time Complexity:
-    - O(n^2) (정렬은 O(n log n), 이중 반복문은 O(n^2))
-Space Complexity:
-    - O(n) (결과 리스트)
+Time Complexity: O(n^2)
+- 정렬은 O(n log n), 이중 반복문은 O(n^2)
+Space Complexity: O(n)
+- 결과 리스트를 저장하는 데 필요한 공간
+
+풀이 방법:
+- 투 포인터를 활용하여 합이 0이 되는 세 수 조합 찾기
+- 배열 정렬: 투 포인터 사용 + 중복 처리 용이
+- for 루프: 첫 번째 숫자 선택 (len(nums)-2까지)
+  - 중복된 첫 번째 숫자 건너뛰기
+  - left, right 포인터 설정
+- while 루프: 두 포인터가 교차하지 않아야 함
+  - sum = nums[i] + nums[left] + nums[right] 계산
+  - sum == 0: 결과 추가, 중복 건너뛰기, 양쪽 포인터 이동
+  - sum < 0: left 증가 (더 큰 값 필요)
+  - sum > 0: right 감소 (더 작은 값 필요)
+- 최종 결과 반환
 """
+# Brute-force: three nested loops → O(n^3)
+# Optimized: sort + two pointer → O(n^2)
 
 class Solution:
     def threeSum(self, nums: List[int]) -> List[List[int]]:
+        # Step 1: Sort the array
+        # Step 2: Fix one number using for loop
+        # Step 3: Use two pointers to find two other numbers
+        #   - if sum == 0: valid triplet
+        #   - if sum < 0: move left pointer
+        #   - if sum > 0: move right pointer
         nums.sort()
         result = []
 

3sum/jiji-hoon96.ts

@@ -0,0 +1,71 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ *
+ * 풀이 1
+ *
+ * 이렇게 푸니까 시간복잡도 O(n^3) / 공간복잡도 O(n) 라서 복잡한 예시에는 time limit 이 발생함
+ * 개선해보자..
+ *
+ * function threeSum(nums: number[]): number[][] {
+ *  nums.sort((a, b) => a - b);
+ *     let result = []
+ *     for (let i= 0; i<nums.length; i++){
+ *         for(let j= i+1 ; j <nums.length; j++){
+ *             for (let k = j+1; k<nums.length; k++){
+ *                 if(nums[i]+nums[j]+nums[k]===0){
+ *                     result.push([nums[i], nums[j], nums[k]]);
+ *                 }
+ *             }
+ *         }
+ *     }
+ *
+ *     return Array.from(
+ *         new Set(result.map(item => JSON.stringify(item))),
+ *         str => JSON.parse(str)
+ *     );
+ *     }
+ *
+ *  풀이 2
+ *
+ *  투포인터를 활용해보자.
+ *  아래처럼 문제를 풀게되면 시간복잡도 O(n^2) / 공간복잡도 O(1) 이다.
+ *  시공간 복잡도가 줄긴하지만 메모리 사용량과 큰 숫자를 다룰 때 성능이 매우 좋다!
+ */
+
+
+function threeSum(nums: number[]): number[][] {
+    let result : number[][] = []
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+
+    for(let first = 0; first<n-2; first++){
+        // 첫번째가 양수면 0이 될 수 없음
+        if(nums[first] > 0) break;
+
+        //중복된 수는 건너뜀
+        if(first > 0 && nums[first]===nums[first-1]) continue;
+
+        let left = first + 1;
+        let right = n-1;
+
+        while(left < right){
+            const sum = nums[first] +nums[left] + nums[right];
+
+            if(sum < 0){
+                left ++
+            }else if(sum > 0){
+                right --;
+            }else{
+                result.push([nums[first],nums[left],nums[right]]);
+                // left, left+1 이 같을 때 중복된 수는 건너뜀
+                while(left < right && nums[left] === nums[left+1]) left++;
+                // right, right+1 이 같을 때 중복된 수는 건너뜀
+                while(left < right && nums[right] === nums[right-1]) right--;
+                left++;
+                right--;
+            }
+        }
+    }
+    return result;
+}

climbing-stairs/jiji-hoon96.ts

@@ -0,0 +1,37 @@
+/**
+ * @param n
+ *
+ * dp, 슬라이딩 윈도우 사용해서 풀 수 있다.
+ *
+ * 공간 복잡도를 줄이기 위해서 아래와같이 슬라이딩을 활용할 수 있다.
+ *
+ * function climbStairs(n: number): number {
+ *     if (n <= 2) return n;
+ *
+ *     let first = 1;  // 1계단을 오르는 방법 수
+ *     let second = 2; // 2계단을 오르는 방법 수
+ *
+ *     for (let i = 3; i <= n; i++) {
+ *         let current = first + second;
+ *         first = second;
+ *         second = current;
+ *     }
+ *
+ *     return second;
+ * }
+ */
+
+
+function climbStairs(n: number): number {
+    if(n <= 2) return n;
+
+    let dp: number[] = new Array(n+1);
+    dp[1] = 1;
+    dp[2] = 2;
+
+    for(let i=3;i<=n;i++){
+        dp[i] = dp[i-1] +dp[i-2];
+    }
+
+    return dp[n]
+};

contains-duplicate/JisuuungKim.py

@@ -0,0 +1,11 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        count = {}
+
+        for i in nums:
+            if i in count:
+                return True
+            else:
+                count[i] = 1
+
+        return False

contains-duplicate/ayleeee.py

@@ -0,0 +1,4 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums))!=len(nums)
+        

contains-duplicate/itschrisjang.java

@@ -0,0 +1,17 @@
+import java.util.HashSet;
+
+class Solution {
+	public boolean containsDuplicate(int[] nums) {
+		HashSet<Integer> numSet  = new HashSet<>();
+    
+		for (int i = 0; i < nums.length; i++) {
+
+			if (numSet.contains(nums[i])) {
+				return true;
+			}
+			numSet.add(nums[i]);
+		}
+    
+		return false;
+	}
+}

contains-duplicate/toychip.java

@@ -0,0 +1,16 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> answer = new HashSet<>();
+        for (int num : nums) {
+            if (!answer.contains(num)) {
+                answer.add(num);
+            } else {
+                return true;
+            }
+        }
+        return false;
+    }
+}

product-of-array-except-self/KwonNayeon.py

@@ -1,25 +1,32 @@
 """
 Constraints:
-  1. 2 <= nums.length <= 10^5
-  2. -30 <= nums[i] <= 30
-  3. The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer
+- 나눗셈 연산 사용 불가능
+- O(n) 시간 복잡도로 구현해야 함
+- 모든 prefix/suffix 곱은 32비트 정수 범위 내에 있음
 
 Time Complexity: O(n)
-  - 배열을 두 번 순회하므로 O(n)
+- 배열을 두 번만 순회
 
 Space Complexity: O(1)
-  - 출력 배열(answer)을 제외하면 추가 공간이 상수만큼만 필요(left, right 변수)
+- 출력 배열 외 추가 공간은 상수만 사용 (left, right 변수)
 
 풀이 방법:
-  1. answer 배열을 1로 초기화 (곱셈에서는 1이 영향을 주지 않음)
-  2. 왼쪽에서 오른쪽으로 순회:
-     - answer[i]에 현재까지의 left 누적값을 곱함
-     - left *= nums[i]로 다음을 위해 left 값을 업데이트
-  3. 오른쪽에서 왼쪽으로 순회 (range(n-1, -1, -1) 사용):
-     - answer[i]에 현재까지의 right 누적값을 곱함
-     - right *= nums[i]로 다음을 위해 right 값을 업데이트
+- 각 위치의 결과는 (왼쪽 모든 요소의 곱) * (오른쪽 모든 요소의 곱)
+- 두 번의 순회로 이를 계산:
+  1. 왼쪽 -> 오른쪽: 각 위치에 왼쪽 모든 요소의 누적 곱 저장
+  2. 오른쪽 -> 왼쪽: 각 위치에 오른쪽 모든 요소의 누적 곱을 곱함
+
+예시: nums = [1, 2, 3, 4]
+1단계 후: answer = [1, 1, 2, 6]
+2단계 후: answer = [24, 12, 8, 6]
 """
 
+# Final result = (product of all elements on the left side) * (product of all elements on the right side)
+
+# Step 1: Initialize result array with 1s
+# Step 2: Traverse from left to right, storing cumulative product of left side
+# Step 3: Traverse from right to left, multiplying with cumulative product of right side
+# nums = [1,2,3,4]
 class Solution:
     def productExceptSelf(self, nums: List[int]) -> List[int]:
         n = len(nums)
@@ -29,10 +36,11 @@ def productExceptSelf(self, nums: List[int]) -> List[int]:
         for i in range(n):
             answer[i] *= left
             left *= nums[i]
-
+# answer = [1, 1, 2, 6] at this point
         right = 1
         for i in range(n-1, -1, -1):
             answer[i] *= right
             right *= nums[i]
-    
+
         return answer
+# answer = [24,12,8,6]

product-of-array-except-self/jiji-hoon96.ts

@@ -0,0 +1,44 @@
+/**
+ *
+ * 풀이 1
+ *
+ * 아래와 같이 문제를 푸니, 성능적으로 문제가 발생했다.
+ * 시간복잡도는 0(n2) / 공간 복잡도는 0(n)
+ *
+ * function productExceptSelf(nums: number[]): number[] {
+ *     if(nums.every(num => num === 0)) return nums; 시간 복잡도 0(n)
+ *     if(nums.length > 2 && nums.filter(num=> num ===0).length > 1) return new Array(nums.length).fill(0) 시간 복잡도 0(n) 공간 복잡도 0(n)
+ *     let result = [] 공간 복잡도 0(n)
+ *     for(let i =0;i<nums.length; i++){ 시간 복잡도 0(n)
+ *         let multi = 1;
+ *         const a= nums.filter((num,index)=> index !== i); 시간 복잡도 0(n) 공간 복잡도 0(n)
+ *         for(let item of a){ 시간 복잡도 0(n)
+ *             multi *= item
+ *         }
+ *         result.push(multi)
+ *     }
+ *     return result
+ * };
+ *
+ * 풀이 2 는 누적합 알고리즘을 사용해서 왼쪽 방향에서 시작해 오른쪽 방향으로 곱하는 방식으로 문제 해결
+ *
+ */
+
+function productExceptSelf(nums: number[]): number[] {
+    const n = nums.length;
+    const result = new Array(n).fill(1);
+
+    let leftProduct = 1;
+    for (let i = 0; i < n; i++) {
+        result[i] *= leftProduct;
+        leftProduct *= nums[i];
+    }
+
+    let rightProduct = 1;
+    for (let i = n - 1; i >= 0; i--) {
+        result[i] *= rightProduct;
+        rightProduct *= nums[i];
+    }
+
+    return result;
+}

top-k-frequent-elements/KwonNayeon.py

@@ -1,21 +1,17 @@
 """
-Title: 237. Top K Frequent Elements
-Link: https://leetcode.com/problems/top-k-frequent-elements/
-
-Question:
-    - Given an integer array `nums` and an integer `k`, return the `k` most frequent elements.
-    - You may return the answer in any order.
+Problem: 237. Top K Frequent Elements
 
 Constraints:
-    - 1 <= nums.length <= 10^5
-    - -10^4 <= nums[i] <= 10^4
-    - k is in the range [1, the number of unique elements in the array].
-    - The answer is guaranteed to be unique.
+- 1 <= nums.length <= 10^5
+- -10^4 <= nums[i] <= 10^4
+- k is in the range [1, the number of unique elements in the array].
+- The answer is guaranteed to be unique.
+
+Time Complexity: O(n log n)
+- 
 
-Time Complexity:
-    - O(n log n)
-Space Complexity:
-    - O(n)
+Space Complexity: O(n)
+- 
 """
 
 # Original Solution