Merge branch 'DaleStudy:main' into main

counting-bits/Leo.py

@@ -0,0 +1,11 @@
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        counter = [0]
+
+        for i in range(1, n + 1):
+            counter.append(counter[i >> 1] + i % 2)
+
+        return counter
+
+        ## TC: O(n), SC: O(n)
+        ## this question should be under math section tbh

counting-bits/WhiteHyun.swift

@@ -0,0 +1,27 @@
+//  
+//  338. Counting Bits
+//  https://leetcode.com/problems/counting-bits/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/05/19.
+//  
+
+final class Solution {
+
+  // MARK: - Time Complexity: O(n), Space Complexity: O(n)
+
+  func countBits(_ n: Int) -> [Int] {
+    var array: [Int] = .init(repeating: 0, count: n + 1)
+    for i in stride(from: 1, through: n, by: 1) {
+      array[i] = array[i >> 1] + (i & 1)
+    }
+    return array
+  }
+
+  // MARK: - nonzeroBitCount
+
+  func countBits2(_ n: Int) -> [Int] {
+    return (0...n).map(\.nonzeroBitCount)
+  }
+
+}

counting-bits/bhyun-kim.py

@@ -0,0 +1,65 @@
+"""
+338. Counting Bits
+https://leetcode.com/problems/counting-bits/description/
+
+Solution 1:
+    - Convert the number to binary string
+    - Sum the number of 1s in the binary string
+    - Append the sum to the output list
+    - Return the output list
+
+Time complexity: O(nlogn)
+    - The for loop runs n times
+    - The sum function runs O(logn) times
+
+Space complexity: O(n)
+    - The output list has n elements
+    
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        output = []
+        for i in range(n + 1):
+            _str = str(bin(i))[2:]
+            _sum = sum(map(int, _str.strip()))
+            output.append(_sum)
+
+        return output
+"""
+
+"""
+Solution 2
+    We can solve this problem with dynamic programming. 
+    1. Initialize output with n elements 
+    2. The first element is 0 because iteration starts from zero. 
+    3. Iterate from 1 to n+1 
+    4. The last digit of each number is 0 for even number 1 for odd number 
+        So add (i & 1) to the output 
+    5. The digits except the last one can be found when the number is divided by two. 
+        Instead for division by two, we can use one step of bit shift to the right. 
+
+    0 = 00000
+    1 = 00001
+    2 = 00010
+    3 = 00011
+    4 = 00100
+    5 = 00101
+    6 = 00110
+    7 = 00111
+
+Time complexity: O(n)
+    - The for loop runs n times
+
+Space complexity: O(n)
+    - The output list has n elements
+"""
+
+from typing import List
+
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        output = [0] * (n+1)
+
+        for i in range(1, n+1):
+            output[i] = output[i >> 1] + (i & 1)
+
+        return output

counting-bits/invidam.go.md

@@ -0,0 +1,45 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+이전 값들을 재활용한다.
+# Approach
+<!-- Describe your approach to solving the problem. -->
+1. 엣지 케이스는 0을 반환한다.
+2. 0, 1을 미리 계산한다.
+3. `>>`을 수행한 결과 + 짝/홀 여부로 인한 1을 더해서 해결해준다.
+- 이진수 `1001`의 경우 `100` 계산한 결괏값에서 `1`을 더해주면 된다.
+- 이진수 `1010`의 경우 `101` 계산한 결괏값에서 `0`을 더해주면 된다.
+
+- 솔루션 참고: `i & (i-1)` 연산을 통해 계산한다.
+    - 2의 제곱수인 경우 `0`이 나와 1을 더하면 된다.
+    - 아닌 경우는 아직은 잘 모르겠다.
+# Complexity
+- Time complexity: $$O(n)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+:`n`크기의 배열을 모두를 순회한다.
+- Space complexity: $$O(n)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+:크기 `n`의 배열을 선언한다.
+# Code
+```go
+func countBits(n int) []int {
+	if n == 0 {
+		return []int{0}
+	}
+	ans := make([]int, n+1, n+1)
+
+	ans[0], ans[1] = 0, 1
+
+	for i := 2; i <= n; i++ {
+		ans[i] = ans[i>>1] + i&1
+	}
+	return ans
+}
+
+func countBitsSolution(n int) []int {
+	res := make([]int, n+1)
+	for i := 1; i <= n; i++ {
+		res[i] = res[i&(i-1)] + 1
+	}
+	return res
+}
+```

counting-bits/nhistory.js

@@ -0,0 +1,26 @@
+var countBits = function (n) {
+  // Create array which has 0 element length of n
+  const dp = new Array(n + 1).fill(0);
+  let offset = 1;
+
+  for (let i = 1; i <= n; i++) {
+    if (offset * 2 === i) offset = i;
+    dp[i] = 1 + dp[i - offset];
+  }
+  return dp;
+};
+
+/**
+      0 -> 0000 -> dp[0] = 0
+      1 -> 0001 -> dp[1] = 1 + dp[1-1] = 1
+      2 -> 0010 -> dp[2] = 1 + dp[2-2] = 1
+      3 -> 0011 -> dp[3] = 1 + dp[3-2] = 2
+      4 -> 0100 -> dp[4] = 1 + dp[4-4] = 1
+      5 -> 0101 -> dp[5] = 1 + dp[5-4] = 2
+      6 -> 0110 -> dp[6] = 1 + dp[6-4] = 2
+      7 -> 0111 -> dp[7] = 1 + dp[7-4] = 3
+      8 -> 1000 -> dp[8] = 1 + dp[8-8] = 1
+   */
+
+// TC: O(n)
+// SC: O(1)

counting-bits/yolophg.js

@@ -0,0 +1,13 @@
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+
+var countBits = function(n) {
+    // initialize an array to hold the result.
+    let ans = new Array(n + 1).fill(0);
+
+    // iterate through all numbers from 1 to n.
+    for (let i = 1; i <= n; i++) {
+        ans[i] = ans[i >> 1] + (i & 1);
+    }
+    return ans;
+};

group-anagrams/Leo.py

@@ -0,0 +1,22 @@
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        ans = collections.defaultdict(list)
+
+        for s in strs:
+            ans[str(sorted(s))].append(s)
+
+        return list(ans.values())
+
+        ## TC: O(n * klogk), SC: O(n * k), where n is len(strs) and k is len(longest_s)
+
+        # ans = {}
+
+        # for s in strs:
+        #     sorted_s = ''.join(sorted(s))
+
+        #     if sorted_s not in ans:
+        #         ans[sorted_s] = []
+
+        #     ans[sorted_s].append(s)
+
+        # return list(ans.values())

group-anagrams/WhiteHyun.swift

@@ -0,0 +1,18 @@
+//  
+//  49. Group Anagrams
+//  https://leetcode.com/problems/group-anagrams/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/05/19.
+//  
+
+final class Solution {
+  func groupAnagrams(_ strs: [String]) -> [[String]] {
+    var dictionary: [String: [String]] = [:]
+    for str in strs {
+      dictionary[String(str.sorted()), default: []].append(str)
+    }
+
+    return Array(dictionary.values)
+  }
+}

group-anagrams/bhyun-kim.py

@@ -0,0 +1,46 @@
+"""
+49. Group Anagrams
+https://leetcode.com/problems/group-anagrams/description/
+
+Solution:
+    - Create a hash table and a list of counters
+    - For each string in the input list:
+        - Sort the string
+        - If the sorted string is in the hash table:
+            - Append the string to the corresponding counter list
+        - Else:
+            - Add the sorted string to the hash table
+            - Create a new counter list and append the string
+    - Return the list of counters
+
+Time complexity: O(nmlogm)
+    - The for loop runs n times
+    - The sorted function runs O(mlogm) times
+    - m is the length of the longest string in the input list
+
+Space complexity: O(n)
+    - The output list has n elements
+    - The hash table has n elements
+    - The list of counters has n elements    
+"""
+
+from typing import List
+
+
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+
+        hash_table = dict()
+        output = []
+
+        for s in strs:
+            count_s = ''.join(sorted(s))
+            if count_s in hash_table:
+                idx = hash_table[count_s]
+                output[idx].append(s)
+            else:
+                hash_table[count_s] = len(output)
+                output.append([s])
+
+        return output
+

group-anagrams/invidam.go.md

@@ -0,0 +1,87 @@
+# Intuition
+정렬된 문자열을 통해 그룹 여부를 쉽게 확인한다.
+# Approach
+1. `{정렬된 문자열, 그 문자열의 인덱스}`를 유지하는 배열을 선언한다.
+2. 원본 배열을 순회하며 정렬한 결과, 인덱스를 struct로 하여 배열에 삽입한다.
+   - 인덱스를 유지하는 이유는 원본 배열의 문자열 값을 확인하기 위함이다. (정렬을 했기에 이렇지 않으면 확인이 어렵다.)
+3. 모든 struct가 삽입된 배열을 문자열을 기준으로 정렬한다.
+4. 반복문을 순회하며 `이전 문자열과 같은지` 여부를 그룹을 판단하여 인덱스들을 그루핑해 모아놓는다.
+5. 그루핑한 인덱스들을 문자열(원본 문자열을 참조해서)로 치환하여 최종적으로 반환한다.
+# Complexity
+- Time complexity: $$O(nklog(n))$$
+<!-- Add your time complexity here, e.g. $$O(nklog(n))$$ -->
+: 배열의 길이 `n`, 문자열의 길이 `k`. 문자열을 기준으로 정렬할 때 발생하는 비용이다.
+- Space complexity: $$O(nk)$$
+
+: 주어진 배열의 길이 `n`, 배열이 가지는 문자열의 길이 `k`, (코드로 생성하는 배열의 길이, 문자열의 크기 모두 `n`, `k`이다.)
+  <!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```go
+type StrAndIdx struct {
+	Str string
+	Idx int
+}
+
+func sortSring(s string) string {
+	runes := []rune(s)
+
+	sort.Slice(runes, func(i, j int) bool {
+		return runes[i] < runes[j]
+	})
+
+	return string(runes)
+}
+
+func groupAnagrams(strs []string) [][]string {
+
+	strAndIdxs := make([]StrAndIdx, 0, len(strs)+5)
+
+	for i, s := range strs {
+		strAndIdxs = append(strAndIdxs, StrAndIdx{sortSring(s), i})
+	}
+
+	sort.Slice(strAndIdxs, func(i, j int) bool {
+		return strAndIdxs[i].Str < strAndIdxs[j].Str
+	})
+
+	groupedIdxs := make([][]int, 0, len(strAndIdxs)/4)
+
+	group := make([]int, 0)
+	defaultString := "NOT_EXIST_STRING"
+	prev := defaultString
+	for _, sAI := range strAndIdxs {
+		curr := sAI.Str
+		idx := sAI.Idx
+		if prev == curr {
+			group = append(group, idx)
+		} else {
+			if prev != defaultString {
+				groupedIdxs = append(groupedIdxs, group)
+			}
+			group = []int{idx}
+		}
+		prev = curr
+	}
+
+	if len(group) != 0 {
+		groupedIdxs = append(groupedIdxs, group)
+	}
+
+	groupedStrs := make([][]string, 0, len(groupedIdxs))
+	for _, idxs := range groupedIdxs {
+
+		groupStr := make([]string, 0, len(idxs))
+		for _, idx := range idxs {
+			groupStr = append(groupStr, strs[idx])
+		}
+		groupedStrs = append(groupedStrs, groupStr)
+	}
+
+	return groupedStrs
+}
+```
+
+# **To** Learn
+- GoLang에서 문자열을 어떻게 비교하는지.
+- 해당 문제 해결에 있어서 삽질한 것은 무엇이었는지. 앞으로 어떻게 해야 안할 수 있는지.

group-anagrams/nhistory.js

@@ -0,0 +1,23 @@
+var groupAnagrams = function (strs) {
+  // Declare hash map to store sorted strs
+  let map = new Map();
+
+  for (let str of strs) {
+    // Sorted each str
+    const sortedStr = str.split("").sort().join("");
+
+    // If there is alread sortedStr on the map, pushed str
+    if (map.has(sortedStr)) {
+      map.get(sortedStr).push(str);
+    } else {
+      // If there is no sortedStr on the map, insert [str]
+      map.set(sortedStr, [str]);
+    }
+  }
+  return Array.from(map.values());
+};
+
+// TC: O(n*klogk)
+// SC: O(n*k)
+// n -> length of strs array
+// k -> amount of character for each element