Merge remote-tracking branch 'upstream/main'

Author: sun912

.github/workflows/integration.yaml

@@ -9,3 +9,77 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: fernandrone/[email protected]
+
+  label-lang:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Create package.json
+        run: echo '{}' > package.json
+
+      - name: Install dependencies
+        run: npm install @octokit/rest node-fetch
+
+      - name: Detect languages and add labels
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+          PR_NUM: ${{ github.event.number }}
+        run: |
+          node --input-type=module -e "
+          import { Octokit } from '@octokit/rest';
+          import path from 'path';
+          import fetch from 'node-fetch';
+
+          const octokit = new Octokit({
+            auth: process.env.GITHUB_TOKEN,
+            request: { fetch }
+          });
+
+          const extensionsToLanguages = {
+            js: 'js',
+            ts: 'ts',
+            py: 'py',
+            java: 'java',
+            kt: 'kotlin',
+            cpp: 'c++',
+            go: 'go',
+            exs: 'elixir',
+            swift: 'swift'
+            // 필요한 다른 확장자와 언어 매핑 추가
+          };
+
+          async function run() {
+            const { data: files } = await octokit.pulls.listFiles({
+              owner: process.env.GITHUB_REPOSITORY.split('/')[0],
+              repo: process.env.GITHUB_REPOSITORY.split('/')[1],
+              pull_number: process.env.PR_NUM,
+            });
+
+            const languages = new Set();
+            files.forEach(file => {
+              const ext = path.extname(file.filename).slice(1);
+              if (extensionsToLanguages[ext]) {
+                languages.add(extensionsToLanguages[ext]);
+              }
+            });
+
+            if (languages.size > 0) {
+              await octokit.issues.addLabels({
+                owner: process.env.GITHUB_REPOSITORY.split('/')[0],
+                repo: process.env.GITHUB_REPOSITORY.split('/')[1],
+                issue_number: process.env.PR_NUM,
+                labels: Array.from(languages),
+              });
+            }
+          }
+
+          run().catch(err => console.error(err));
+          "

contains-duplicate/f-exuan21.java

@@ -0,0 +1,16 @@
+// time : O(n)
+// space : O(n)
+
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for(int i : nums) {
+            if(set.contains(i)) {
+                return true;
+            }
+            set.add(i);
+        }
+        return false;
+    }
+}
+

contains-duplicate/hajunyoo.py

@@ -0,0 +1,7 @@
+class Solution:
+    # Time complexity: O(n)
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        string_len = len(nums)
+        set_len = len(set(nums))
+
+        return string_len != set_len

kth-smallest-element-in-a-bst/f-exuan21.java

@@ -0,0 +1,50 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+
+    private int count = 0;
+    private TreeNode resultNode = null;
+
+    public int kthSmallest(TreeNode root, int k) {
+        searchNode(root, k);
+        return resultNode.val;
+    }
+
+    public void searchNode(TreeNode node, int k) {
+
+        if(resultNode != null) return;
+
+        if(node.left != null) {
+            searchNode(node.left, k); 
+        }
+
+        count++;
+
+        if(count == k) {
+            resultNode = node;
+            return;
+        }
+
+        if(node.right != null) {
+            searchNode(node.right, k);
+        }
+    }
+}
+
+// n : 노드 개수
+// time : O(n) 최악의 경우 모든 노드를 탐색해야함
+// space : O(n) 최악의 경우 한 쪽으로 노드가 치우쳐져 있음 
+// -> 재귀 호출이 이루어지므로 스택에 쌓임 -> 한 쪽으로 쏠려 있으면 트리의 높이가 n이 됨 (트리의 최대 높이가 스택의 최대 깊이)

kth-smallest-element-in-a-bst/hajunyoo.py

@@ -0,0 +1,30 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import defaultdict
+
+
+class Solution:
+    # Time complexity: O(n)
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        self.count = 0
+        self.result = 0
+
+        def dfs(node):
+            if not node:
+                return
+
+            dfs(node.left)
+
+            self.count += 1
+            if self.count == k:
+                self.result = node.val
+                return
+
+            dfs(node.right)
+
+        dfs(root)
+        return self.result

number-of-1-bits/f-exuan21.java

@@ -0,0 +1,16 @@
+// time : O(1) 
+// space : O(1)
+
+class Solution {
+    public int hammingWeight(int n) {
+        int count = 0;
+
+        while(n != 0) {
+            if((n&1) == 1) count++;
+            n = n >> 1;
+        }
+
+        return count;
+    }
+}
+

number-of-1-bits/hajunyoo.py

@@ -0,0 +1,9 @@
+class Solution:
+    # Time complexity: O(log n)
+    def hammingWeight(self, n: int) -> int:
+        cnt = 0
+        while n > 0:
+            if n % 2 == 1:
+                cnt += 1
+            n = n // 2
+        return cnt

palindromic-substrings/hajunyoo.py

@@ -0,0 +1,19 @@
+class Solution:
+    # Time complexity: O(n^2) = O(n) * O(n)
+    def countSubstrings(self, s: str) -> int:
+        self.count = 0
+        n = len(s)
+
+        def two_pointer_expand(left, right):
+            while left >= 0 and right < n and s[left] == s[right]:
+                self.count += 1
+                left -= 1
+                right += 1
+
+        for i in range(0, n):
+            # 1, 3, 5 ...
+            two_pointer_expand(i, i)
+            # 2, 4, 6 ...
+            two_pointer_expand(i, i + 1)
+
+        return self.count

top-k-frequent-elements/f-exuan21.java

@@ -0,0 +1,39 @@
+
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for(int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        
+        PriorityQueue<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>(
+            (a, b) -> Integer.compare(b.getValue(), a.getValue())
+        );
+
+        for(Map.Entry<Integer, Integer> entry : map.entrySet()) {
+            queue.offer(entry);
+        }
+
+        int[] res = new int[k];
+
+        for(int i = 0; i < k; i++) {
+            res[i] = queue.poll().getKey();
+        }
+
+        return res;
+    }
+}
+
+// n : nums의 길이
+// m : nums에서 서로 다른 숫자의 개수
+
+// time : O(n) + O(m*logm) + O(k*logm) = O(n + m*logm + k*logm)
+// 최악의 경우, nums 가 다 unique 하기 때문에 n == m == k 가 됨
+// 따라서, O(n*logn)
+
+// space : O(m) + O(m) + O(k) = O(m + k)
+// 최악의 경우 n == m == k 가 됨
+// 따라서, O(n)
+
+
+

top-k-frequent-elements/hajunyoo.py

@@ -0,0 +1,20 @@
+from collections import defaultdict
+from typing import List
+
+
+class Solution:
+    # Time complexity: O(nlogn) -> O(n) + O(nlogn) + O(k)
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        counter_dict = defaultdict(int)
+
+        for n in nums:
+            counter_dict[n] += 1
+
+        count_list = []
+        for key, val in counter_dict.items():
+            count_list.append((key, val))
+
+        count_list.sort(key=lambda x: x[1], reverse=True)
+        answer = [a for a, b in count_list[:k]]
+
+        return answer