Merge branch 'DaleStudy:main' into main

Author: yolophg

3sum/dev-jonghoonpark.md

@@ -0,0 +1,52 @@
+- 문제 : https://leetcode.com/problems/3sum/
+- time complexity : O(n^2)
+- space complexity : O(1) (결과값을 고려하지 않은 알고리즘 자체의 공간 복잡도)
+- 블로그 링크 : https://algorithm.jonghoonpark.com/2024/05/07/leetcode-15
+
+```java
+public List<List<Integer>> threeSum(int[] nums) {
+    Arrays.sort(nums);
+
+    List<List<Integer>> result = new ArrayList<>();
+
+    int lastOne = Integer.MIN_VALUE;
+    for (int i = 0; i < nums.length - 1; i++) {
+        int num = nums[i];
+        if (lastOne == num) {
+            continue;
+        }
+
+        twoSum(result, nums, i);
+        lastOne = num;
+    }
+
+    return result;
+}
+
+public void twoSum(List<List<Integer>> result, int[] nums, int targetIndex) {
+    int target = -nums[targetIndex];
+
+    int i = targetIndex + 1;
+    int j = nums.length - 1;
+    while (i < j) {
+        int twoSum = nums[i] + nums[j];
+
+        if (target > twoSum) {
+            i++;
+        }
+
+        if (target < twoSum) {
+            j--;
+        }
+
+        if (target == twoSum) {
+            result.add(List.of(-target, nums[i], nums[j]));
+            int current = nums[i];
+            while (i < nums.length - 2 && current == nums[i + 1]) {
+                i++;
+            }
+            i++;
+        }
+    }
+}
+```

3sum/nhistory.js

@@ -0,0 +1,43 @@
+var threeSum = function (nums) {
+  // Sort nums array
+  const sortedNums = nums.sort((a, b) => a - b);
+  let result = [];
+
+  // Start iteration to pick first element for 3sum
+  for (let i = 0; i < sortedNums.length; i++) {
+    // Check if the first element is already greater than 0, no valid triplets possible after this point
+    if (sortedNums[i] > 0) {
+      break;
+    }
+
+    // Skip duplicates of the first element to avoid redundant triplets
+    if (i > 0 && sortedNums[i] === sortedNums[i - 1]) {
+      continue;
+    }
+
+    // Iterate to find sum of two pointer and nums[i]
+    let left = i + 1;
+    let right = sortedNums.length - 1;
+
+    while (left < right) {
+      let sum = sortedNums[i] + sortedNums[left] + sortedNums[right];
+
+      if (sum === 0) {
+        result.push([sortedNums[i], sortedNums[left], sortedNums[right]]);
+        // Skip duplicates of left and right pointers to avoid redundant triplets
+        while (sortedNums[left] === sortedNums[left + 1]) left++;
+        while (sortedNums[right] === sortedNums[right - 1]) right--;
+        left++;
+        right--;
+      } else if (sum < 0) {
+        left++;
+      } else if (sum > 0) {
+        right--;
+      }
+    }
+  }
+  return result;
+};
+
+// TC: O(n^2)
+// SC: O(n)

encode-and-decode-strings/dev-jonghoonpark.md

@@ -0,0 +1,29 @@
+- 문제
+  - 유료 : https://leetcode.com/problems/encode-and-decode-strings/
+  - 무료 : https://www.lintcode.com/problem/659/
+- time complexity : O(n)
+- space complexity : O(n \* m), m은 각 문자열 길이의 평균
+- 블로그 링크 : https://algorithm.jonghoonpark.com/2024/05/29/leetcode-271
+
+```java
+public String encode(List<String> strs) {
+    StringBuilder sb = new StringBuilder();
+    for (String str : strs) {
+        sb.append(str.replace("%", "%25").replace(",", "%2C")).append(",");
+    }
+    return sb.length() > 0 ? sb.toString() : "";
+}
+
+public List<String> decode(String str) {
+    List<String> decodedList = new ArrayList<>();
+    if (str.length() > 0) {
+        int commaIndex = str.indexOf(",");
+        while (commaIndex > -1) {
+            decodedList.add(str.substring(0, commaIndex).replace("%2C", ",").replace("%25", "%"));
+            str = str.substring(commaIndex + 1);
+            commaIndex = str.indexOf(",");
+        }
+    }
+    return decodedList;
+}
+```

encode-and-decode-strings/nhistory.js

@@ -0,0 +1,43 @@
+class Solution {
+  /**
+   * @param {string[]} strs
+   * @returns {string}
+   */
+  encode(strs) {
+    let result = "";
+    for (let str of strs) {
+      result += str.length.toString() + "#" + str;
+    }
+    return result;
+  }
+
+  /**
+   * @param {string} str
+   * @returns {string[]}
+   */
+  decode(str) {
+    let result = [];
+    let i = 0;
+
+    while (i < str.length) {
+      // Find the position of the next '#'
+      let j = i;
+      while (str[j] !== "#") {
+        j++;
+      }
+
+      // Length of the next string
+      const len = parseInt(str.slice(i, j));
+      i = j + 1; // Move past the '#'
+
+      // Extract the string of length 'len'
+      result.push(str.slice(i, i + len));
+      i += len; // Move past the extracted string
+    }
+
+    return result;
+  }
+}
+
+// TC: O(n),O(n)
+// SC: O(n),O(n)

longest-consecutive-sequence/dev-jonghoonpark.md

@@ -0,0 +1,28 @@
+- 문제 : https://leetcode.com/problems/longest-consecutive-sequence/
+- time complexity : O(n)
+- space complexity : O(n)
+- 블로그 링크 : https://algorithm.jonghoonpark.com/2024/05/28/leetcode-128
+
+```java
+public int longestConsecutive(int[] nums) {
+    Set<Integer> set = new HashSet<>();
+
+    for(int num : nums) {
+        set.add(num);
+    }
+
+    int max = 0;
+    for(int num : set) {
+        if (!set.contains(num - 1)) {
+            int current = 1;
+            while (set.contains(num + 1)) {
+                current++;
+                num++;
+            }
+            max = Math.max(current, max);
+        }
+    }
+
+    return max;
+}
+```

longest-consecutive-sequence/nhistory.js

@@ -0,0 +1,30 @@
+var longestConsecutive = function (nums) {
+  // Return 0 if there are no elements in nums
+  if (nums.length === 0) return 0;
+
+  // Create a set to find values efficiently
+  const numSet = new Set(nums);
+  let maxLength = 0;
+
+  for (let num of numSet) {
+    // Check if this is the start of a sequence
+    if (!numSet.has(num - 1)) {
+      let currentNum = num;
+      let currentLength = 1;
+
+      // Count the length of the sequence
+      while (numSet.has(currentNum + 1)) {
+        currentNum += 1;
+        currentLength += 1;
+      }
+
+      // Update the maximum length
+      maxLength = Math.max(maxLength, currentLength);
+    }
+  }
+
+  return maxLength;
+};
+
+// TC: O(n)
+// SC: O(n)

product-of-array-except-self/dev-jonghoonpark.md

@@ -0,0 +1,75 @@
+- 문제 : https://leetcode.com/problems/product-of-array-except-self/
+- time complexity : O(n)
+- space complexity : O(n)
+- 블로그 링크 : https://algorithm.jonghoonpark.com/2024/05/08/leetcode-238
+
+## case 나눠서 풀기
+
+```java
+public int[] productExceptSelf(int[] nums) {
+    int[] products = new int[nums.length];
+    int result = 1;
+    int zeroCount = 0;
+
+    int p = 0;
+    while (p < nums.length) {
+        if (nums[p] != 0) {
+            result *= nums[p];
+        } else {
+            zeroCount++;
+            if (zeroCount >= 2) {
+                Arrays.fill(products, 0);
+                return products;
+            }
+        }
+        p++;
+    }
+
+    if (zeroCount == 1) {
+        p = 0;
+        while (p < nums.length) {
+            if (nums[p] == 0) {
+                products[p] = result;
+            }
+            p++;
+        }
+    } else {
+        p = 0;
+        while (p < nums.length) {
+            products[p] = result / nums[p];
+            p++;
+        }
+    }
+
+    return products;
+}
+```
+
+## 재밋는 방법으로 풀기 (prefixProd)
+
+```java
+public int[] productExceptSelf(int[] nums) {
+    int[] result = new int[nums.length];
+
+    int[] prefixProd = new int[nums.length];
+    int[] suffixProd = new int[nums.length];
+
+    prefixProd[0] = nums[0];
+    for (int i = 1; i < nums.length; i++) {
+        prefixProd[i] = prefixProd[i-1] * nums[i];
+    }
+
+    suffixProd[nums.length - 1] = nums[nums.length - 1];
+    for (int i = nums.length - 2; i > -1; i--) {
+        suffixProd[i] = suffixProd[i + 1] * nums[i];
+    }
+
+    result[0] = suffixProd[1];
+    result[nums.length - 1] = prefixProd[nums.length - 2];
+    for (int i = 1; i < nums.length - 1; i++) {
+        result[i] = prefixProd[i - 1] * suffixProd[i + 1];
+    }
+
+    return result;
+}
+```

product-of-array-except-self/nhistory.js

@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function (nums) {
+  const len = nums.length;
+  const lastIndex = len - 1;
+
+  // Declare prefix, postfix array
+  let prefix = new Array(len).fill(1);
+  let postfix = new Array(len).fill(1);
+
+  // Iterate loop to add prefix[i-1]*nums[i] values into prefix array
+  prefix[0] = nums[0];
+  for (let i = 1; i < nums.length; i++) {
+    prefix[i] = prefix[i - 1] * nums[i];
+  }
+
+  // Iterate loop to add postfix[i]*nums[i-1] values into postfix array
+  postfix[lastIndex] = nums[lastIndex];
+  for (let i = lastIndex; i >= 1; i--) {
+    postfix[i - 1] = postfix[i] * nums[i - 1];
+  }
+
+  // Make output array with prefix and postfix arrays
+  let output = new Array(len).fill(1);
+
+  // First index value is equal to postfix[1]
+  output[0] = postfix[1];
+  // Last index value is equal to prefix[lastIndex-1]
+  output[lastIndex] = prefix[lastIndex - 1];
+  for (let i = 1; i < len - 1; i++) {
+    output[i] = prefix[i - 1] * postfix[i + 1];
+  }
+
+  return output;
+};
+
+// TC: O(n)
+// SC: O(n)

top-k-frequent-elements/dev-jonghoonpark.md

@@ -0,0 +1,24 @@
+- 문제 : https://leetcode.com/problems/top-k-frequent-elements/
+- time complexity : O(nlogn)
+- space complexity : O(n)
+- 블로그 링크 : https://algorithm.jonghoonpark.com/2024/04/18/leetcode-347
+
+```java
+public int[] topKFrequent(int[] nums, int k) {
+    Map<Integer, Integer> counter = new HashMap<>();
+
+    Arrays.stream(nums)
+            .forEach(num -> {
+                counter.put(num, counter.getOrDefault(num, 0) + 1);
+            });
+
+    return Arrays.copyOfRange(counter.entrySet().stream()
+            .sorted(Map.Entry.<Integer, Integer>comparingByValue().reversed())
+            .mapToInt(Map.Entry::getKey)
+            .toArray(), 0, k);
+}
+```
+
+## tc, sc 관련 그렇게 생각한 이유
+
+빈도를 기준으로 map을 생성하기 때문에 n 보다 적은 경우가 대다수 이겠지만, 최악의 경우 n개의 map entry가 생성될 수 잇음.

top-k-frequent-elements/nhistory.js

@@ -0,0 +1,14 @@
+var topKFrequent = function (nums, k) {
+  // 1. Hashmap { num : frequency }
+  let map = {};
+
+  // 2. Iterate counts frequency of each value
+  for (num of nums) {
+    // Check there is already num key or not
+    if (!map[num]) map[num] = 0;
+    map[num]++;
+  }
+
+  // 3. Sort frequency and return sliced array
+  return [...Object.keys(map)].sort((a, b) => map[b] - map[a]).slice(0, k);
+};