Merge pull request #1254 from ready-oun/week2/solutions

[ready-oun] WEEK 02 Solutions

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)
+ */

climbing-stairs/ready-oun.java

@@ -0,0 +1,25 @@
+class Solution {
+    public int climbStairs(int n) {
+        if (n <= 2) return n; // base cases 
+
+        int first = 1; // f(1)
+        int second = 2; // f(2)
+
+        // bottom-up dp: s to n 
+        for (int i = 3; i <= n; i++) {
+            int current = first + second; // f(i) = f(i-1) + f(i-2) 
+            first = second; // 
+            second = current; 
+        }
+        return second; 
+    }
+}
+
+/**
+    Fibonacci-like DP problem -> f(n) = f(n-1) + f(n-2)
+    (n 번째 칸에 오르는 방법의 개수) = (n-1 번째 칸에 오르는 방법의 개수) + (n-2 번째 칸에 오르는 방법의 개수)
+    - Time Complexity: O(n) 
+        loop from 3 to n once 
+    - Space Complexity: O(1)
+        only 2 var are used 
+ */

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] 로 누적 
+ */

valid-anagram/ready-oun.java

@@ -0,0 +1,25 @@
+import java.util.Arrays;
+
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        // If len diff, they can't be anagram 
+        if (s.length() != t.length()) return false; 
+
+        // convert to char arr & sort 
+        char[] sArr = s.toCharArray(); 
+        char[] tArr = t.toCharArray(); 
+        Arrays.sort(sArr); 
+        Arrays.sort(tArr); 
+
+        // comp sorted arr 
+        return Arrays.equals(sArr, tArr); 
+
+        // runtime: 4ms 
+    }
+}
+
+/**
+ * 정렬 2번 → O(n log n)
+ * 배열 비교 → O(n)
+ * 전체: O(n log n) (성능은 나쁘지 않음)
+ */