solve: 3sum & product except self

Author: ready-oun

3sum/ready-oun.java

@@ -0,0 +1,64 @@
+import java.util.Arrays; 
+import java.util.ArrayList; 
+import java.util.List; 
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums); 
+        List<List<Integer>> result = new ArrayList<>(); 
+
+        for (int i = 0; i < nums.length - 2; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) continue; 
+
+            int left = i + 1; 
+            int right = nums.length - 1; 
+
+            while (left < right) {
+                int sum = nums[i] + nums[left] + nums[right]; 
+
+                if (sum == 0) {
+                    
+                    // result.add(Arrays.asList(nums[i], nums[left], nums[right])); 
+                    List<Integer> triplet = new ArrayList<>(); 
+                    triplet.add(nums[i]); 
+                    triplet.add(nums[left]); 
+                    triplet.add(nums[right]); 
+
+                    result.add(triplet); 
+
+                    while (left < right && nums[left] == nums[left + 1]) left++; 
+                    while (left < right && nums[right] == nums[right - 1]) right--; 
+
+                    left++;
+                    right--; 
+                    
+                } else if (sum < 0) {
+                    left++;     
+                } else {
+                    right--; 
+                }
+            }
+        }
+        return result; 
+    }   
+}
+
+/**
+    Two pointers - fix 1 and use 2 ptrs
+    nums[i] + nums[L] + nums[R] == 0
+    no duplicates 
+
+    1. sort array
+    2. skip repeats
+        - nums[i] == nums[i - 1] 
+        - nums[left] == nums[left + 1]
+        - nums[right] == nums[right - 1] 
+    3. check if sum == 0
+    4. move L right if sum < 0 
+    5. move R left if sum > 0 else 
+
+    List<Integer>: [0, 0, 0]
+    List<List<Integer>>: [[0, 0, 0], [-2, -3, 5]] 
+    nums.length - 2까지만 반복: for no out of bounds 
+        (last 2 val for left, right each)
+ */

product-of-array-except-self/ready-oun.java

@@ -0,0 +1,36 @@
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int n = nums.length; 
+        int[] answer = new int[n]; 
+
+        // prefix product 
+        answer[0] = 1; 
+        for (int i = 1; i < n; i++) {
+            answer[i] = answer[i - 1] * nums[i - 1]; 
+        }
+
+        // suffix product 
+        int suffix = 1; 
+        for (int i = n - 1; i >= 0; i--) {
+            answer[i] *= suffix; // answer의 prefix에 곱 ->  자기 자신 제외한 전체 곱 완성
+            suffix *= nums[i]; // suffix 갱신 (*nums[i] 누적)
+        }
+
+        return answer; 
+    }
+}
+
+/**
+    return int[] answer 
+    -> product of all nums except nums[i]
+
+    prefix -> answer[i] = nums[0] * nums[1] * ... * nums[i-1]
+    answer[i-1] * nums[i-1] 로 점화식 표현. 
+    suffix -> suffix[i] = nums[i+1] * nums[i+2] * ... * nums[n-1]
+
+    MUST: O(n) time w/o division like total product / nums[i] 
+
+    answer[i] = prefix[i] * suffix[i]; 
+    but in O(1) extra space complexity 
+    -> no extra arr for suffix -> var suf *= nums[i] 로 누적 
+ */