Merge branch 'DaleStudy:main' into main

Author: meoooh

3sum/Leo.py

@@ -0,0 +1,26 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+
+        nums.sort()
+        res = []
+
+        for i, ch in enumerate(nums):
+            if i > 0 and nums[i] == nums[i - 1]: continue
+
+            l, r = i + 1, len(nums) - 1
+            while l < r:
+                threeSum = ch + nums[l] + nums[r]
+
+                if threeSum < 0:
+                    l += 1
+                elif threeSum > 0:
+                    r -= 1
+                else:
+                    res.append([ch, nums[l], nums[r]])
+                    l += 1
+                    while l < r and nums[l] == nums[l - 1]:
+                        l += 1
+
+        return res
+
+        ## TC: O(n^2), SC: O(1)

3sum/WhiteHyun.swift

@@ -0,0 +1,41 @@
+//  
+//  15. 3Sum
+//  https://leetcode.com/problems/3sum/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/06/04.
+//  
+
+class Solution {
+  func threeSum(_ nums: [Int]) -> [[Int]] {
+    var result: [[Int]] = []
+    let sorted = nums.sorted()
+
+    for (index, element) in sorted.enumerated() where index <= 0 || element != sorted[index - 1] {
+      var left = index + 1
+      var right = sorted.count - 1
+
+      while left < right {
+        let threeSum = element + sorted[left] + sorted[right]
+        if threeSum > 0 {
+          right -= 1
+          continue
+        }
+        if threeSum < 0 {
+          left += 1
+          continue
+        }
+
+        result.append([element, sorted[left], sorted[right]])
+        left += 1
+
+        while sorted[left] == sorted[left - 1] && left < right {
+          left += 1
+        }
+      }
+    }
+
+
+    return result
+  }
+}

3sum/bhyun-kim.py

@@ -0,0 +1,83 @@
+"""
+15. 3Sum
+https://leetcode.com/problems/3sum/description/
+
+Solution: 
+    - Sort the list
+    - Iterate through the list
+    - For each element, find the two elements that sum up to -element
+    - Use two pointers to find the two elements
+    - Skip the element if it is the same as the previous element
+    - Skip the two elements if they are the same as the previous two elements
+    - Add the set to the output list
+
+    Example:
+        -----------------------------------------
+        low :    |
+        high:              |   
+            i : |
+                [-4,-1,-1,0,1,2]
+
+        -----------------------------------------
+        low :      |
+        high:              |   
+            i : |
+                [-4,-1,-1,0,1,2]
+
+                ... no possible set with i=-4, and high=2
+
+        -----------------------------------------
+        low :       |
+        high:              |   
+            i :     |
+                [-4,-1,-1,0,1,2]
+
+
+Time complexity: O(n^2)
+    - O(nlogn) for sorting
+    - O(n^2) for iterating through the list and finding the two elements
+    - Total: O(n^2)
+Space complexity: O(n)
+    - O(n) for the output list
+    - O(n) for the prevs dictionary
+    - O(n) for the prevs_n set
+    - Total: O(n)
+"""
+
+
+from typing import List
+
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums = sorted(nums)
+        output = []
+        prevs = dict()
+        prevs_n = set()
+
+        for i in range(len(nums) - 2):
+            n_i = nums[i]
+
+            if n_i in prevs_n:
+                continue
+            else:
+                prevs_n.add(n_i)
+
+            low, high = i + 1, len(nums) - 1
+            while low < high:
+                n_low = nums[low]
+                n_high = nums[high]
+                if n_i + n_low + n_high == 0:
+                    if not f"[{n_i},{n_low},{n_high}]" in prevs:
+                        prevs[f"[{n_i},{n_low},{n_high}]"] = 1
+                        output.append([n_i, n_low, n_high])
+                    low += 1
+                    high -= 1
+
+                elif n_i + n_low + n_high < 0:
+                    low += 1
+
+                elif n_i + n_low + n_high > 0:
+                    high -= 1
+
+        return output

3sum/evan.js

@@ -0,0 +1,60 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+  const sorted = nums.sort((a, b) => a - b);
+  const result = [];
+
+  for (let i = 0; i < sorted.length; i++) {
+    const fixedNumber = sorted[i];
+    const previousFixedNumber = sorted[i - 1];
+
+    if (fixedNumber === previousFixedNumber) {
+      continue;
+    }
+
+    let [leftEnd, rightEnd] = [i + 1, sorted.length - 1];
+
+    while (leftEnd < rightEnd) {
+      const sum = fixedNumber + sorted[leftEnd] + sorted[rightEnd];
+
+      if (sum === 0) {
+        result.push([sorted[leftEnd], sorted[rightEnd], sorted[i]]);
+
+        while (
+          sorted[leftEnd + 1] === sorted[leftEnd] ||
+          sorted[rightEnd - 1] === sorted[rightEnd]
+        ) {
+          if (sorted[leftEnd + 1] === sorted[leftEnd]) {
+            leftEnd += 1;
+          }
+
+          if (sorted[rightEnd - 1] === sorted[rightEnd]) {
+            rightEnd -= 1;
+          }
+        }
+
+        leftEnd += 1;
+        rightEnd -= 1;
+      } else if (sum < 0) {
+        leftEnd += 1;
+      } else {
+        rightEnd -= 1;
+      }
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Time Complexity: O(n^2)
+ * The algorithm involves sorting the input array, which takes O(n log n) time.
+ * The main part of the algorithm consists of a loop that runs O(n) times, and within that loop, there is a two-pointer technique that runs in O(n) time.
+ * Thus, the overall time complexity is O(n log n) + O(n^2), which simplifies to O(n^2).
+ *
+ * Space Complexity: O(n)
+ * The space complexity is O(n) due to the space needed for the sorted array and the result array.
+ * Although the sorting algorithm may require additional space, typically O(log n) for the in-place sort in JavaScript, the dominant term is O(n) for the result storage.
+ */

3sum/invidam.go.md

@@ -0,0 +1,59 @@
+# Intuition
+예전에 풀어봤던 문제였어서 접근법을 알고있었다.
+
+# Approach
+1. 정렬을 하여 배열의 대소관계를 일정하게 한다.
+2. i,j,k를 설정해야 하는데, i < j < k이도록 한다.
+3. i는 맨 앞에서부터 순회한다.
+4. j는 i의 뒤부터 순회한다.
+5. k는 맨 뒤에서부터 순회한다.
+6. 세 인덱스가 가리키는 값들의 합을 비교하여 j와 k를 수정한다.
+
+# Complexity
+- Time complexity: $$O(n^2)$$
+  - 입력 배열의 길이 n에 대하여, `i`, `j와 k`를 순회한다.
+
+- Space complexity: $$O(n)$$
+  - 입력으로 들어온 배열의 길이 n에 대하여, 생성하는 결과 배열의 길이 역시 이와 동일하다.
+# Code
+
+```go
+func update(i int, j int, k int, sum int, nums []int) (int, int) {
+	if sum <= 0 {
+		j++
+		for j < len(nums) && j >= 1 && nums[j] == nums[j-1] {
+			j++
+		}
+	} else {
+		k--
+		for k >= 0 && k+1 < len(nums) && nums[k] == nums[k+1] {
+			k--
+		}
+	}
+
+	return j, k
+}
+
+func threeSum(nums []int) [][]int {
+	var triplets [][]int
+
+	sort.Ints(nums)
+	for i := 0; i < len(nums); i++ {
+		j, k := i+1, len(nums)-1
+
+		if i != 0 && nums[i-1] == nums[i] {
+			continue
+		}
+
+		for j < k {
+			sum := nums[i] + nums[j] + nums[k]
+			if sum == 0 {
+				triplets = append(triplets, []int{nums[i], nums[j], nums[k]})
+			}
+			j, k = update(i, j, k, sum, nums)
+		}
+	}
+	return triplets
+}
+
+```

3sum/samthekorean.py

@@ -0,0 +1,29 @@
+# O(n^2) where there is nested loop.
+# O(1) where high and low are reused as constant values.
+
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        # Initialize a set to store unique triplets
+        triplets = set()
+
+        # Sort the list to make two-pointer approach possible
+        nums.sort()
+
+        # Iterate through the list, considering each element as a potential first element of a triplet
+        for i in range(len(nums) - 2):
+            low = i + 1
+            high = len(nums) - 1
+
+            # To avoid duplicate iteration
+            while low < high:
+                three_sum = nums[i] + nums[low] + nums[high]
+
+                if three_sum < 0:
+                    low += 1
+                elif three_sum > 0:
+                    high -= 1
+                else:
+                    triplets.add((nums[i], nums[low], nums[high]))
+                    low += 1
+                    high -= 1

3sum/yolophg.js

@@ -0,0 +1,34 @@
+// Time Complexity: O(n^2)
+// Space Complexity: O(n)
+
+// Time Complexity: O(n^2)
+// Space Complexity: O(n)
+
+var threeSum = function(nums) {
+    nums.sort((a, b) => a - b);
+    // create a set to store triplets.
+    const result = new Set();
+
+    // loop through the array, but stop 2 elements before the end.
+    for (let i = 0; i < nums.length - 2; i++) {
+        // if the current element is the same as the one before it, skip it to avoid duplicates.
+        if (i > 0 && nums[i] === nums[i - 1]) continue;
+    
+        // create a set to keep track of the complements.
+        const complements = new Set();
+        // start another loop from the next element.
+        for (let j = i + 1; j < nums.length; j++) {
+            const complement = -nums[i] - nums[j];
+            // check if the current number is in the set.
+            if (complements.has(nums[j])) {
+                // if it is, found a triplet. Add it to the result set as a sorted string to avoid duplicates.
+                result.add(JSON.stringify([nums[i], complement, nums[j]].sort((a, b) => a - b)));
+            } else {
+                complements.add(complement);
+            }
+        }
+    }
+
+    // convert set of strings back to arrays.
+    return Array.from(result).map(triplet => JSON.parse(triplet));
+};

container-with-most-water/README.md

@@ -0,0 +1,2 @@
+- 문제: https://leetcode.com/problems/container-with-most-water/
+- 풀이: https://www.algodale.com/problems/container-with-most-water/

counting-bits/bky373.java

@@ -0,0 +1,23 @@
+/**
+ * https://leetcode.com/problems/counting-bits/
+ *
+ * time: O(n * log n)
+ * space: O(1)
+ */
+class Solution {
+
+    public int[] countBits(int n) {
+        int[] ans = new int[n + 1];
+        for (int i = 0; i <= n; i++) {
+            int x = i;
+            int cnt = 0;
+            while (x != 0) {
+                cnt++;
+                x &= (x - 1);
+            }
+            ans[i] = cnt;
+        }
+        return ans;
+    }
+}
+

encode-and-decode-strings/Leo.py

@@ -0,0 +1,26 @@
+class Codec:
+    def encode(self, strs: List[str]) -> str:
+        """Encodes a list of strings to a single string.
+        """
+        res = ''
+
+        for s in strs:
+            res += str(len(s)) + '#' + s
+
+        return res
+
+    def decode(self, s: str) -> List[str]:
+        """Decodes a single string to a list of strings.
+        """
+        res = []
+
+        i = 0
+        while i < len(s):
+            a = s.find('#', i)
+            length = int(s[i:a])
+            res.append(s[a + 1:a + 1 + length])
+            i = a + 1 + length
+
+        return res
+
+        ## TC: O(n), SC:O(n),n denotes sum of all len(s)