Merge branch 'DaleStudy:main' into main

Author: yolophg

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/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

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/

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)

encode-and-decode-strings/bhyun-kim.py

@@ -0,0 +1,34 @@
+"""
+271. Encode and Decode Strings
+https://leetcode.com/problems/encode-and-decode-strings/description/
+
+Solution:
+    - Concatenate the strings with a special character
+    - Split the string by the special character
+
+Time complexity: O(n)
+    - Concatenating the strings: O(n)
+    - Splitting the string: O(n)
+    - Total: O(n)
+
+Space complexity: O(n)
+    - Storing the output: O(n)
+    - Total: O(n)
+"""
+from typing import List
+
+
+class Codec:
+    def encode(self, strs: List[str]) -> str:
+        """Encodes a list of strings to a single string."""
+        output = strs[0]
+
+        for i in range(1, len(strs)):
+            output += "é" + strs[i]
+
+        return output
+
+    def decode(self, s: str) -> List[str]:
+        """Decodes a single string to a list of strings."""
+
+        return s.split("é")

encode-and-decode-strings/evan.js

@@ -0,0 +1,58 @@
+const DELIMITER = "#";
+
+/**
+ *
+ * @param {string[]} strs
+ * @returns {string}
+ */
+function encode(strs) {
+  return strs.map((s) => `${s.length}${DELIMITER}${s}`).join("");
+}
+
+/**
+ *
+ * @param {string} encodedStr
+ * @returns {string[]}
+ */
+function decode(encodedStr) {
+  const decodedStrings = [];
+  let currentIndex = 0;
+
+  while (currentIndex < encodedStr.length) {
+    let delimiterIndex = currentIndex;
+
+    while (encodedStr[delimiterIndex] !== DELIMITER) {
+      delimiterIndex += 1;
+    }
+
+    const strLength = parseInt(
+      encodedStr.substring(currentIndex, delimiterIndex)
+    );
+
+    decodedStrings.push(
+      encodedStr.substring(delimiterIndex + 1, delimiterIndex + 1 + strLength)
+    );
+
+    currentIndex = delimiterIndex + 1 + strLength;
+  }
+
+  return decodedStrings;
+}
+/**
+ * Time Complexity: O(n) where n is the length of the encoded string.
+ * Reason:
+ *  The inner operations (finding # and extracting substrings) are proportional to the size of the encoded segments
+ *  but are ultimately bounded by the total length of the input string.
+ *
+ * Space Complexity: O(k) where k is the total length of the decoded strings.
+ */
+
+/**
+ * Test cases
+ */
+const strs4 = ["longestword", "short", "mid", "tiny"];
+const encoded4 = encode(strs4);
+console.log(encoded4); // Output: "11#longestword5#short3#mid4#tiny"
+
+const decoded4 = decode(encoded4);
+console.log(decoded4); // Output: ["longestword", "short", "mid", "tiny"]

encode-and-decode-strings/invidam.go.md

@@ -0,0 +1,70 @@
+# Intuition
+구분자를 넣어 오류를 방지한다.
+# Approach
+<!-- Describe your approach to solving the problem. -->
+1. UTF-8에 벗어나는 구분자 `ㄱ`을 넣어 구분했다.
+# Complexity
+- Time complexity: $$O(n)$$ 
+  - 문자열의 길이 n에 대하여, 이를 순회하는 비용이 발생한다.
+
+- Space complexity: $$O(n)$$
+  - 문자열의 길이 n에 대하여, `encoded`를 만드는 공간이 발생한다.
+
+# Code
+```go
+const DIVIDE_CHAR_V1 = 'ㄱ'
+func encodeV1(strs []string) string {
+	ret := strings.Join(strs, string(DIVIDE_CHAR_V1))
+	return ret
+}
+
+func decodeV1(encoded string) []string {
+	sep := string(DIVIDE_CHAR_V1)
+	return strings.Split(encoded, sep)
+}
+```
+- - -
+# Intuition
+솔루션에서 네트워크 통신을 위한다는 목적을 듣고 수정해보았다. (유니코드를 넣는 게 의도는 아닌 듯했다.)
+# Approach
+1. 구분자 (`-`)와 이전 문자의 길이를 함께 저장한다.
+2. 구분자가 나온다면, 문자열의 길이를 추출하여 문자열을 디코딩한다.
+3. 위 과정을 배열을 순회하며 반복한다.
+# Complexity
+- Time complexity: $$O(n)$$
+  - 문자열의 길이 n에 대하여, 이를 순회하는 비용이 발생한다.
+
+- Space complexity: $$O(n)$$
+  - 문자열의 길이 n에 대하여, `encoded`를 만드는 공간이 발생한다.
+
+# Code
+```go
+const DIVIDE_CHAR = '-'
+func encode(strs []string) string {
+	ret := ""
+	for _, str := range strs {
+		ret += str
+		ret += fmt.Sprintf("%c%04d", DIVIDE_CHAR, len(str))
+		// a-1bcd-3
+	}
+	return ret
+}
+
+func decode(encoded string) []string {
+	ret := make([]string, 0)
+	for i := 0; i < len(encoded); {
+		if encoded[i] == DIVIDE_CHAR {
+			lenStr := encoded[i+1 : i+5]
+			len, _ := strconv.Atoi(lenStr)
+
+			decodeStr := encoded[i-len : i]
+			ret = append(ret, decodeStr)
+			i += 5
+		} else {
+			i += 1
+		}
+	}
+
+	return ret
+}
+```

encode-and-decode-strings/samthekorean.py

@@ -0,0 +1,70 @@
+class Solution:
+    """
+    @param: strs: a list of strings
+    @return: encodes a list of strings to a single string.
+    """
+
+    # TC : O(n) where n is the combined length of the string in the list of strings.
+    # SC : O(S), where S is the sum of the lengths of all strings in strs
+    def encode(self, strs):
+        res = ""
+        for s in strs:
+            res += str(len(s)) + ":" + s
+        return res
+
+    """
+    @param: str: A string
+    @return: decodes a single string to a list of strings
+    """
+
+    # TC : O(n) where n is the length of encoded string
+    # SC : O(S), where S is the total length of the decoded strings.
+    def decode(self, str):
+        res, i = [], 0
+
+        while i < len(str):
+            j = i
+            while str[j] != ":":
+                j += 1
+            length = int(str[i:j])
+            res.append(str[j + 1 : j + length + 1])
+            i = j + 1 + length
+
+        return res
+
+
+def test_solution():
+    solution = Solution()
+
+    # Test case 1: Basic test case
+    input_strs = ["hello", "world"]
+    encoded = solution.encode(input_strs)
+    decoded = solution.decode(encoded)
+    print(f"Test case 1\nEncoded: {encoded}\nDecoded: {decoded}\n")
+
+    # Test case 2: Empty list
+    input_strs = []
+    encoded = solution.encode(input_strs)
+    decoded = solution.decode(encoded)
+    print(f"Test case 2\nEncoded: {encoded}\nDecoded: {decoded}\n")
+
+    # Test case 3: List with empty strings
+    input_strs = ["", "", ""]
+    encoded = solution.encode(input_strs)
+    decoded = solution.decode(encoded)
+    print(f"Test case 3\nEncoded: {encoded}\nDecoded: {decoded}\n")
+
+    # Test case 4: List with mixed empty and non-empty strings
+    input_strs = ["abc", "", "def"]
+    encoded = solution.encode(input_strs)
+    decoded = solution.decode(encoded)
+    print(f"Test case 4\nEncoded: {encoded}\nDecoded: {decoded}\n")
+
+    # Test case 5: List with special characters
+    input_strs = ["he:llo", "wo:rld"]
+    encoded = solution.encode(input_strs)
+    decoded = solution.decode(encoded)
+    print(f"Test case 5\nEncoded: {encoded}\nDecoded: {decoded}\n")
+
+
+test_solution()

find-minimum-in-rotated-sorted-array/README.md

@@ -0,0 +1,2 @@
+- 문제: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
+- 풀이: https://www.algodale.com/problems/find-minimum-in-rotated-sorted-array/

longest-consecutive-sequence/Leo.py

@@ -0,0 +1,18 @@
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+
+        seen = set(nums)
+        longest = 0
+
+        for n in seen:
+            if (n - 1) not in seen:
+                length = 1
+
+                while (n + length) in seen:
+                    length += 1
+
+                longest = max(length, longest)
+
+        return longest
+
+        ## TC: O(n), SC: O(n)

longest-consecutive-sequence/bhyun-kim.py

@@ -0,0 +1,40 @@
+"""
+128. Longest Consecutive Sequence
+https://leetcode.com/problems/longest-consecutive-sequence/description/
+
+Solution:
+    - Create a set of the input list
+    - Iterate through the set
+    - For each element, find the consecutive elements
+    - Use a while loop to find the consecutive elements
+    - Update the longest length
+
+Time complexity: O(n)
+    - O(n) for iterating through the set
+
+Space complexity: O(n)
+    - O(n) for the set
+    - Total: O(n)
+
+"""
+
+from typing import List
+
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        longest_len = 0
+        nums_set = set(nums)
+
+        for n in nums_set:
+            if n - 1 not in nums_set:
+                current_n = n
+                current_len = 1
+
+                while current_n + 1 in nums_set:
+                    current_n += 1
+                    current_len += 1
+
+                longest_len = max(longest_len, current_len)
+
+        return longest_len

longest-consecutive-sequence/evan.js

@@ -0,0 +1,38 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function (nums) {
+  const set = new Set(nums);
+  let longestStreak = 0;
+
+  for (const num of set) {
+    // Check if it's the start of a sequence
+    if (!set.has(num - 1)) {
+      let currentNum = num;
+      let currentStreak = 1;
+
+      // Find the length of the sequence
+      while (set.has(currentNum + 1)) {
+        currentNum += 1;
+        currentStreak += 1;
+      }
+
+      longestStreak = Math.max(longestStreak, currentStreak);
+    }
+  }
+
+  return longestStreak;
+};
+
+/**
+ * Time Complexity: O(n) where n is the length of the input array.
+ * Reason:
+ *   Creating the Set: O(n)
+ *   Iterating Through the Set: O(n)
+ *   Checking for the Start of a Sequence: O(n)
+ *   Finding the Length of the Sequence: O(n) across all sequences
+ *   Tracking the Longest Sequence: O(n)
+ *
+ * Space Complexity: O(n) because of the additional space used by the set.
+ */

longest-consecutive-sequence/invidam.go.md

@@ -0,0 +1,75 @@
+# Intuition
+자기 자신 이후에 몇 개가 연속되었는지를 `dp`로 저장한다.
+# Approach
+1. 등장 여부를 `appear`에 기록한다.
+2. 자기 자신 이후 연속된 원소의 개수를 반환하는 함수를 만들고 매 배열마다 이를 호출한다.
+    - `dp`로써, 자기 자신(`from`)에 따른 결과들을 유지한다.
+    - 자기 자신이 등장했는지 여부에 따라 `0` 혹은 `다음 연속 개수 + 1`을 반환한다. 
+3. 호출 결과 중 최대를 찾아 반환한다.
+# Complexity
+- Time complexity: $$O(nlog(n))$$
+
+- Space complexity: $$O(n+m)$$
+# Code
+## Original
+```go
+func longestConsecutiveFrom(num int, appear map[int]bool, cache map[int]int) (ret int) {
+	if val, ok := cache[num]; ok {
+		return val
+	}
+
+	if _, ok := appear[num]; ok {
+		ret = longestConsecutiveFrom(num+1, appear, cache) + 1
+	} else {
+		ret = 0
+	}
+	cache[num] = ret
+	return ret
+}
+
+func longestConsecutive(nums []int) int {
+	appear := make(map[int]bool, len(nums)/2)
+	cache := make(map[int]int, len(nums)/2)
+	for _, num := range nums {
+		appear[num] = true
+	}
+
+	var max int
+
+	for _, num := range nums {
+		ret := longestConsecutiveFrom(num, appear, cache)
+		if ret > max {
+			max = ret
+		}
+	}
+	return max
+}
+```
+
+## Bottom-up
+```go
+func longestConsecutive(nums []int) int {
+	appear := make(map[int]bool, len(nums)/2)
+	for _, num := range nums {
+		appear[num] = true
+	}
+
+	var max int
+
+	for _, num := range nums {
+		if appear[num-1] {
+			continue
+		}
+		len := 1
+		for appear[num+len] {
+			len++
+		}
+
+		if len > max {
+			max = len
+		}
+	}
+	return max
+}
+
+```

longest-consecutive-sequence/samthekorean.py

@@ -0,0 +1,15 @@
+# TC : O(n) where n is the length of nums
+# SC : O(n) where n is the size of nums
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        numSet = set(nums)
+        longest = 0
+
+        for n in nums:
+            # check whether its the start of the sequence
+            if (n - 1) not in numSet:
+                length = 0
+                while (n + length) in numSet:
+                    length += 1
+                longest = max(length, longest)
+        return longest

longest-repeating-character-replacement/README.md

@@ -0,0 +1,2 @@
+- 문제: https://leetcode.com/problems/longest-repeating-character-replacement/
+- 풀이: https://www.algodale.com/problems/longest-repeating-character-replacement/

longest-substring-without-repeating-characters/README.md

@@ -0,0 +1,2 @@
+- 문제: https://leetcode.com/problems/longest-substring-without-repeating-characters/
+- 풀이: https://www.algodale.com/problems/longest-substring-without-repeating-characters/

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

@@ -0,0 +1,16 @@
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        length = len(nums)
+        res = [1] * length
+        ltor = 1
+        rtol = 1
+
+        for i in range(length):
+            res[i] *= ltor
+            ltor = ltor * nums[i]
+            res[length - i - 1] *= rtol
+            rtol = rtol * nums[length - i - 1]
+
+        return res
+
+        ## TC: O(n), SC: O(1) 

product-of-array-except-self/bhyun-kim.py

@@ -0,0 +1,65 @@
+"""
+238. Product of Array Except Self
+https://leetcode.com/problems/product-of-array-except-self/description/
+
+Solution:
+    - Create two lists to store the product of elements from the left and right
+    - Multiply the elements from the left and right lists to get the output
+
+    Example:
+        nums = [4, 2, 3, 1, 7, 0, 9, 10]
+
+        left is numbers to the left of the current index
+        right is numbers to the right of the current index
+        from_left is the product of the numbers to the left of the current index
+        from_right is the product of the numbers to the right of the current index
+
+        i = 0: (4) 2 3 1 7 0 9 10
+        i = 1: 4 (2) 3 1 7 0 9 10
+        i = 2: 4 2 (3) 1 7 0 9 10
+        i = 3: 4 2 3 (1) 7 0 9 10
+        i = 4: 4 2 3 1 (7) 0 9 10
+        i = 5: 4 2 3 1 7 (0) 9 10
+        i = 6: 4 2 3 1 7 0 (9) 10
+        i = 7: 4 2 3 1 7 0 9 (10)
+
+        from_left = [0, 4, 8, 24, 24, 168, 0, 0]
+        from_right = [0, 0, 0, 0, 0, 90, 10, 0]
+        output = [0, 0, 0, 0, 0, 15120, 0, 0]
+
+Time complexity: O(n)
+    - Calculating the product of the elements from the left: O(n)
+    - Calculating the product of the elements from the right: O(n)
+    - Calculating the output: O(n)
+    - Total: O(n)
+
+Space complexity: O(n)
+    - Storing the product of the elements from the left: O(n)
+    - Storing the product of the elements from the right: O(n)
+    - Storing the output: O(n)
+"""
+from typing import List
+
+
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        output = [0] * len(nums)
+
+        from_left = [0] * (len(nums))
+        from_right = [0] * (len(nums))
+
+        from_left[0] = nums[0]
+        from_right[-1] = nums[-1]
+
+        for i in range(1, len(nums) - 1):
+            from_left[i] = from_left[i - 1] * nums[i]
+
+        for i in reversed(range(1, len(nums) - 1)):
+            from_right[i] = from_right[i + 1] * nums[i]
+
+        output[0] = from_right[1]
+        output[-1] = from_left[-2]
+        for i in range(1, len(nums) - 1):
+            output[i] = from_left[i - 1] * from_right[i + 1]
+
+        return output

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

@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function (nums) {
+  const length = nums.length;
+  const result = Array(length).fill(1);
+
+  let leftProduct = 1;
+  for (let i = 0; i < length; i++) {
+    result[i] = leftProduct;
+    leftProduct *= nums[i];
+  }
+
+  let rightProduct = 1;
+  for (let i = length - 1; i >= 0; i--) {
+    result[i] *= rightProduct;
+    rightProduct *= nums[i];
+  }
+
+  return result;
+};
+
+/**
+ * Time Complexity: O(n)
+ * The algorithm iterates through the nums array twice (two separate loops), each taking O(n) time.
+ * Hence, the overall time complexity is O(2n), which simplifies to O(n).
+ *
+ * Space Complexity: O(1)
+ * The algorithm uses a constant amount of extra space for the leftProduct and rightProduct variables.
+ * The result array is not considered extra space as it is required for the output.
+ * Therefore, the extra space complexity is O(1).
+ */

product-of-array-except-self/invidam.go.md

@@ -0,0 +1,46 @@
+# Intuition
+0의 등장 횟수에 따라 경우의 수가 달라진다. 이를 이용한다.
+# Approach
+(사이트에서 Wrong Case를 제공하였기에 다양한 경우의 수를 대응할 수 있었다, 좋은 풀이는 아니라고 생각한다.)
+- 모든 수의 곱을 계산한 후, 배열을 순회하며 자기 자신을 나눈 값을 저장한다.
+- 0이 등장한 경우, 0이 아닌 배열의 원소들은 무조건 0을 저장해야 한다.
+  - `golang`의 경우 `int`의 기본값이 0이라 아무것도 안해주면 된다.
+- 0이 2회 이상 등장한 경우, 모든 원소는 0이 된다.
+    - `golang`의 경우 길이만 선언된 `int` 배열을 반환하면 된다.
+# Complexity
+- Time complexity: $$O(n)$$
+  - 배열의 길이 n에 대하여, 순회하는 비용 n이 발생한다.
+
+- Space complexity: $$O(n)$$
+  - 배열의 길이 n에 대하여, 결과를 저장할 배열의 크기 n이 소모된다.
+# Code
+```go
+func productExceptSelf(nums []int) []int {
+	answer := make([]int, len(nums))
+	product := 1
+	zeroCnt := 0
+	for _, num := range nums {
+		if num == 0 {
+			zeroCnt++
+			continue
+		}
+		product *= num
+	}
+
+	if zeroCnt >= 2 {
+		product = 0
+	}
+
+	for i, num := range nums {
+		if num == 0 {
+			answer[i] = product
+		} else if zeroCnt == 0 {
+			answer[i] = product / num
+		}
+	}
+	return answer
+}
+```
+# 여담
+부분곱문제로 해결하기 적합하다는 생각이 들었으나, `0`처리 때문에 시도해보진 않았다.
+솔루션들을 보며 좌, 우에 대해 2번을 사용하는 방법이 있다는 걸 알게되었다.

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

@@ -0,0 +1,18 @@
+# TC : O(n)
+# SC : O(1)
+
+
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        ans = [1] * (len(nums))
+
+        prefix = 1
+        for i in range(len(nums)):
+            ans[i] = prefix
+            prefix *= nums[i]
+        postfix = 1
+        for i in range(len(nums) - 1, -1, -1):
+            ans[i] *= postfix
+            postfix *= nums[i]
+
+        return ans

search-in-rotated-sorted-array/README.md

@@ -0,0 +1,2 @@
+- 문제: https://leetcode.com/problems/search-in-rotated-sorted-array/
+- 풀이: https://www.algodale.com/problems/search-in-rotated-sorted-array/

top-k-frequent-elements/Leo.py

@@ -0,0 +1,17 @@
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+
+        num_dict = collections.Counter(nums)
+        freq = num_dict.most_common()
+        ans = []
+
+        for key, val in freq:
+            if k == 0:
+                break
+
+            ans.append(key)
+            k -= 1
+
+        return ans
+
+        ## TC: O(n * logn), SC: O(n)

top-k-frequent-elements/bhyun-kim.py

@@ -0,0 +1,43 @@
+"""
+347. Top K Frequent Elements
+https://leetcode.com/problems/top-k-frequent-elements/description/
+
+Solution:
+    - Count the frequency of each element in the list
+    - Sort the dictionary by the frequency in descending order
+    - Return the first k elements in the sorted dictionary
+
+Time complexity: O(nlogn)
+    - Counting the frequency of each element: O(n)
+    - Sorting the dictionary: O(nlogn)
+    - Returning the first k elements: O(k)
+        k <= n
+    - Total: O(nlogn)
+
+Space complexity: O(n)
+    - Storing the frequency of each element: O(n)
+    - Storing the sorted dictionary: O(n)
+    - Storing the output: O(k)
+        k <= n
+"""
+from collections import OrderedDict
+from typing import List
+
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        n_dict = OrderedDict()
+
+        for n in nums:
+            if n in n_dict:
+                n_dict[n] += 1
+            else:
+                n_dict[n] = 1
+
+        n_dict = sorted(n_dict.items(), key=lambda x: x[1], reverse=True)
+
+        output = [0] * k
+        for i in range(k):
+            output[i] = n_dict[i][0]
+
+        return output

top-k-frequent-elements/evan.js

@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function (nums, k) {
+  const counter = new Map();
+
+  nums.forEach((num) => {
+    if (counter.has(num)) {
+      counter.set(num, counter.get(num) + 1);
+    } else {
+      counter.set(num, 1);
+    }
+  });
+
+  const sorted = [...counter.entries()].sort(
+    ([, freqA], [, freqB]) => freqB - freqA
+  );
+
+  return sorted.slice(0, k).map(([num]) => num);
+};
+
+/**
+ * Time Complexity: O(n log n)
+ * - Counting the frequency of each element takes O(n) time.
+ * - Sorting the entries by frequency takes O(n log n) time.
+ * - Extracting the top k elements and mapping them takes O(k) time.
+ * - Therefore, the overall time complexity is dominated by the sorting step, resulting in O(n log n).
+
+ * Space Complexity: O(n)
+ * - The counter map requires O(n) space to store the frequency of each element.
+ * - The sorted array also requires O(n) space.
+ * - Therefore, the overall space complexity is O(n).
+ */

top-k-frequent-elements/invidam.go.md

@@ -0,0 +1,49 @@
+# Intuition
+빈도수 계산, 정렬을 활용하면 가능하다고 생각했다. (깔끔하진 않아 해결될지는 의문이었다.)
+# Approach
+1. 빈도 수를 저장한다.
+2. 원소들을 빈도수(내림차순)대로 정렬한다.
+3. 정렬된 원소 중 앞에서부터 k개를 반환한다.
+# Complexity
+- Time complexity: $$O(nlog(n))$$
+  - 배열의 길이 n에 대하여, 정렬비용으로 소모된다.
+
+- Space complexity: $$O(n+k)$$
+  - 배열의 길이 n과 원소의 범위 k에 대하여, 빈도수 저장을 위해 선언하는 비용 `k`와 정렬된 원소를 저장하는 비용 `n`이 소모된다.
+
+# Code
+```go
+type NumAndFreq struct {
+	Num  int
+	Freq int
+}
+
+func topKFrequent(nums []int, k int) []int {
+	freq := make(map[int]int, 20000)
+
+	for _, num := range nums {
+		freq[num]++
+	}
+
+	numAndFreqs := make([]NumAndFreq, 0, len(freq))
+	for n, f := range freq {
+		numAndFreqs = append(numAndFreqs, NumAndFreq{Num: n, Freq: f})
+	}
+
+	sort.Slice(numAndFreqs, func(i, j int) bool {
+		return numAndFreqs[i].Freq > numAndFreqs[j].Freq
+	})
+
+	numsSortedByFreqDesc := make([]int, 0, len(nums))
+	for _, e := range numAndFreqs {
+		numsSortedByFreqDesc = append(numsSortedByFreqDesc, e.Num)
+	}
+
+	return numsSortedByFreqDesc[0:k]
+}
+
+```
+
+# 여담
+- 타 솔루션들을 보며 정렬을 하지 않고 빈도수별로 원소들을 모아놨다가 배열을 만드는 방법도 확인했다. 직관적이진 않다고 느꼈다.
+- 문제 해결 도중 `map`, `filter`와 같은 함수형 프로그래밍을 활용하면 좋겠다는 생각이 들어 golang에서도 이를 제공하나 찾아봤다. [링크1](https://stackoverflow.com/questions/71624828/is-there-a-way-to-map-an-array-of-objects-in-go)과 [링크2](https://github.com/golang/go/issues/45955)를 통해 다양한 논의가 있었으나, 여러 이유로 도입하지 않음을 알게되었다. 

top-k-frequent-elements/samthekorean.py

@@ -0,0 +1,31 @@
+# TC : O(n)
+# SC : O(n)
+from collections import defaultdict
+
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        # Initialize a list of empty lists to store numbers based on their frequencies
+        freq = [[] for i in range(len(nums) + 1)]
+
+        # Dictionary to count the frequency of each number
+        counter = defaultdict(int)
+
+        # Count the frequency of each number in nums
+        for num in nums:
+            counter[num] += 1
+
+        # Group numbers by their frequency
+        for n, c in counter.items():
+            freq[c].append(n)
+
+        # Result list to store the top k frequent elements
+        res = []
+
+        # Iterate over the frequency list in reverse order to get the most frequent elements first
+        for i in range(len(freq) - 1, 0, -1):
+            for n in freq[i]:
+                res.append(n)
+                # Once we have k elements in the result, return it
+                if len(res) == k:
+                    return res