Merge branch 'DaleStudy:main' into main

Author: 8804who

.github/workflows/integration.yaml

@@ -2,12 +2,10 @@ name: Integration 🔄
 
 on:
   pull_request:
-  merge_group:
 
 jobs:
   linelint:
     runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request'
     steps:
       - uses: actions/checkout@v4
         with:

contains-duplicate/deepInTheWoodz.py

@@ -0,0 +1,8 @@
+class Solution:
+  def containsDuplicate(self, nums: List[int]) -> bool:
+    s = set()
+    for num in nums:
+      if num in s:
+        return True
+      s.add(num)
+    return False

contains-duplicate/devyejin.py

@@ -1,4 +1,9 @@
-class Solution(object):
-    def containsDuplicate(self, nums):
-        return len(nums) != len(set(nums))
+from typing import List
+"""
+time complexity : O(n)
+space complexity : O(n)
+"""
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums)) == len(nums)
 

contains-duplicate/ljh981009.ts

@@ -0,0 +1,4 @@
+function containsDuplicate(nums: number[]): boolean {
+  const result = new Set(nums);
+  return result.size !== nums.length;
+}

contains-duplicate/pastelto.java

@@ -0,0 +1,14 @@
+/*
+    Return true when array contains duplicated number
+ */
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        HashSet<Integer> set = new HashSet<>();
+
+        for (int num : nums) {
+            if (set.contains(num)) return true;
+            set.add(num);
+        }
+        return false;
+    }
+}

reverse-bits/DaleSeo.rs

@@ -0,0 +1,19 @@
+// TC: O(1)
+// SC: O(1)
+impl Solution {
+    pub fn reverse_bits(n: i32) -> i32 {
+        let mut result = 0u32;
+        let mut num = n as u32;
+
+        for i in 0..32 {
+            // Extract the least significant bit
+            let bit = num & 1;
+            // Place it in the reversed position
+            result |= bit << (31 - i);
+            // Shift num right to process the next bit
+            num >>= 1;
+        }
+
+        result as i32
+    }
+}

top-k-frequent-elements/deepInTheWoodz.py

@@ -0,0 +1,11 @@
+class Solution:
+  def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+    counter = dict()
+
+    for num in nums:
+      if num in counter:
+        counter[num] += 1
+      else:
+        counter[num] = 1
+
+    return [num[0] for num in sorted(counter.items(), key=lambda x: x[1])[-k:]]

top-k-frequent-elements/devyejin.py

@@ -1,9 +1,16 @@
+"""
+time complexity: O(nlogn)
+space complexity: O(n)
+"""
+
+from typing import List
 from collections import Counter
-import heapq
+from heapq import nlargest
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        count = Counter(nums)
+        return [num for num, _ in nlargest(k, count.items(), key=lambda x: x[1])]
 
 
-class Solution(object):
-    def topKFrequent(self, nums, k):
-        counter = sorted(Counter(nums).items(), key=lambda item: -item[1])
-        return list(num for num, count in counter[:k])
 

two-sum/deepInTheWoodz.py

@@ -0,0 +1,9 @@
+class Solution:
+  def twoSum(self, nums: List[int], target: int) -> List[int]:
+    passed = dict()
+    
+    for i, num in enumerate(nums):
+      other = target - num
+      if other in passed:
+        return [passed[other], i]
+      passed[num] = i

two-sum/devyejin.py

@@ -1,15 +1,12 @@
-class Solution(object):
-    def twoSum(self, nums, target):
+from typing import List
 
-        nums_tuple = sorted(list(enumerate(nums)), key=lambda x: x[1])
-        left, right = 0, len(nums) - 1
 
-        while left < right:
-            temp_sum = nums_tuple[left][1] + nums_tuple[right][1]
-            if temp_sum == target:
-                return [nums_tuple[left][0], nums_tuple[right][0]]
-            elif temp_sum < target:
-                left += 1
-            else:
-                right -= 1
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        seen = {}
+        for idx, num in enumerate(nums):
+            need = target - num
+            if need in seen:
+                return [idx, seen[need]]
+            seen[num] = idx