Merge branch 'DaleStudy:main' into main

Author: liza0525

.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:

3sum/daiyongg-kim.py

@@ -0,0 +1,36 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+
+        result = []
+        n = len(nums)
+
+        for i in range(n - 2):
+            
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+            
+            left = i + 1  
+            right = n - 1 
+            while left < right:
+                current_sum = nums[i] + nums[left] + nums[right]
+
+                if current_sum == 0:
+                    result.append([nums[i], nums[left], nums[right]])
+
+                    while left < right and nums[left] == nums[left + 1]:
+                        left += 1
+
+                    while left < right and nums[right] == nums[right - 1]:
+                        right -= 1
+                        
+                    left += 1
+                    right -= 1
+                 
+                elif current_sum < 0:
+                    left += 1
+                
+                else: 
+                    right -= 1
+            
+        return result

climbing-stairs/daiyongg-kim.py

@@ -0,0 +1,13 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        if n == 1:
+            return 1
+        
+        prev, curr = 1, 2 
+
+        for i in range(3, n+1):
+            next = prev + curr
+            prev = curr
+            curr = next
+        
+        return curr

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;
+    }
+}

linked-list-cycle/DaleSeo.rs

@@ -0,0 +1,28 @@
+// Definition for singly-linked list.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>,
+}
+
+// TC: O(n)
+// SC: O(1)
+impl Solution {
+    pub fn has_cycle(head: Option<Box<ListNode>>) -> bool {
+        let mut slow = &head;
+        let mut fast = &head;
+
+        while fast.is_some() && fast.as_ref().unwrap().next.is_some() {
+            slow = &slow.as_ref().unwrap().next;
+            fast = &fast.as_ref().unwrap().next.as_ref().unwrap().next;
+
+            if slow.as_ref().map(|node| node.as_ref() as *const _)
+                == fast.as_ref().map(|node| node.as_ref() as *const _)
+            {
+                return true;
+            }
+        }
+
+        false
+    }
+}

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

@@ -0,0 +1,20 @@
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        
+        size = len(nums)
+
+        #initialize array as 1 
+        result = [1] * size
+
+        left_pass = 1
+
+        for i in range(size):A
+            result[i] *= left_pass
+            left_pass *= nums[i]
+
+        right_pass = 1
+        for i in range(size-1, -1, -1):
+            result[i] *= right_pass
+            right_pass *= nums[i]
+
+        return result

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
+    }
+}