Merge remote-tracking branch 'upstream/main'

Author: keunsun.lee

.github/workflows/integration.yaml

@@ -0,0 +1,11 @@
+name: 🔄 Integration
+
+on:
+  pull_request:
+
+jobs:
+  linelint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: fernandrone/[email protected]

.linelint.yml

@@ -0,0 +1,18 @@
+# 'true' will fix files
+autofix: false
+
+# list of paths to ignore, uses gitignore syntaxes (executes before any rule)
+ignore:
+  - "*.md"
+
+rules:
+  # checks if file ends in a newline character
+  end-of-file:
+    # set to true to enable this rule
+    enable: true
+
+    # set to true to disable autofix (if enabled globally)
+    disable-autofix: false
+
+    # if true also checks if file ends in a single newline character
+    single-new-line: false

binary-tree-level-order-traversal/WhiteHyun.swift

@@ -104,4 +104,4 @@ class Solution {
 
     return array
   }
-}
+}

contains-duplicate/0-chan.ts

@@ -0,0 +1,8 @@
+/**
+ * time complexity : O(n)
+ * space complexity : O(n)
+ */
+function containsDuplicate(nums: number[]): boolean {
+    const hasDuplicate = new Set(nums).size !== nums.length;
+    return hasDuplicate;
+};

contains-duplicate/EGON.py

@@ -0,0 +1,60 @@
+from unittest import TestCase, main
+from typing import List
+from collections import Counter
+
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return self.solve_3(nums=nums)
+
+    """
+    Runtime: 412 ms (Beats 75.17%)
+    Analyze Complexity: O(n)
+    Memory: 31.92 MB (Beats 45.93%)
+    """
+    def solve_1(self, nums: List[int]) -> bool:
+        return len(nums) != len(set(nums))
+
+    """
+    Runtime: 423 ms (Beats 39.66%)
+    Analyze Complexity: O(n)
+    Memory: 34.54 MB (Beats 14.97%)
+    """
+    def solve_2(self, nums: List[int]) -> bool:
+        counter = {}
+        for num in nums:
+            if num in counter:
+                return True
+            else:
+                counter[num] = True
+        else:
+            return False
+
+    """
+    Runtime: 441 ms (Beats 16.59%)
+    Analyze Complexity: O(n)
+    Memory: 34.57 MB (Beats 14.97%)
+    """
+    def solve_3(self, nums: List[int]) -> bool:
+        return Counter(nums).most_common(1)[0][1] > 1
+
+
+class _LeetCodeTCs(TestCase):
+    def test_1(self):
+        nums = [1, 2, 3, 1]
+        output = True
+        self.assertEqual(Solution.containsDuplicate(Solution(), nums=nums), output)
+
+    def test_2(self):
+        nums = [1, 2, 3, 4]
+        output = False
+        self.assertEqual(Solution.containsDuplicate(Solution(), nums=nums), output)
+
+    def test_3(self):
+        nums = [1, 1, 1, 3, 3, 4, 3, 2, 4, 2]
+        output = True
+        self.assertEqual(Solution.containsDuplicate(Solution(), nums=nums), output)
+
+
+if __name__ == '__main__':
+    main()

contains-duplicate/EGON.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+class Solution {
+    func containsDuplicate(_ nums: [Int]) -> Bool {
+        return solve_2(nums)
+    }
+    
+    /*
+         Runtime: 246 ms (Beats 68.44%)
+         Analyze Complexity: O(n)
+         Memory: 19.94 MB (Beats 76.01%)
+     */
+    func solve_1(_ nums: [Int]) -> Bool {
+        return nums.count != Set(nums).count
+    }
+    
+    /*
+         Runtime: 240 ms (Beats 90.56%)
+         Analyze Complexity: O(n)
+         Memory: 22.56 MB (Beats 33.43%)
+     */
+    func solve_2(_ nums: [Int]) -> Bool {
+        var counter: [Int: Bool] = [:]
+        for num in nums {
+            if counter[num] != nil {
+                return true
+            } else {
+                counter[num] = true
+            }
+        }
+        
+        return false
+    }
+}

contains-duplicate/GUMUNYEONG.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+    const setObj = new Set(nums);
+
+    const diff = !(nums.length === setObj.size);
+
+    return diff;
+};
+
+// TC: O(n)
+// SC: O(n)

contains-duplicate/HC-kang.ts

@@ -0,0 +1,21 @@
+/**
+217. Contains Duplicate
+
+Example 1:
+Input: nums = [1,2,3,1]
+Output: true
+
+Example 2:
+Input: nums = [1,2,3,4]
+Output: false
+
+Example 3:
+Input: nums = [1,1,1,3,3,4,3,2,4,2]
+Output: true
+ */
+
+// Time complexity: O(n)
+// Space complexity: O(n)
+function containsDuplicate(nums: number[]): boolean {
+  return nums.length !== new Set(nums).size;
+}

contains-duplicate/Raft.py

@@ -0,0 +1,12 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        appeared = defaultdict(int)
+        for n in nums:
+            if appeared[n] > 0:
+                return True
+            appeared[n] += 1
+        
+        return False
+# T: O(n)
+# S: O(n)
+

contains-duplicate/TonyKim9401.java

@@ -0,0 +1,17 @@
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        // HashSet  O(n)
+        /*
+        Set<Integer> set = new HashSet();
+        for (int num : nums) set.add(num);
+        return set.size() != nums.length;
+        */
+
+        // dupl value O(n log n)
+        Arrays.sort(nums);
+        for (int i = 0; i < nums.length - 1; i++) {
+            if (nums[i] == nums[i + 1]) return true;
+        }
+        return false;
+    }
+}