Merge remote-tracking branch 'upstream/main'

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

contains-duplicate/bemelon.py

@@ -0,0 +1,10 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        # Time Complexity: O(n)
+        # Space Complexity: O(n)
+        seen = set()
+        for num in nums:
+            if num in seen:
+                return True 
+            seen.add(num)
+        return False

contains-duplicate/dm.py

@@ -0,0 +1,6 @@
+from typing import List
+
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(nums) != len(set(nums))

contains-duplicate/flynn.cpp

@@ -0,0 +1,24 @@
+/**
+ * for given size of input nums N,
+ * 
+ * Time complexity: O(N)
+ *   - iteration: O(N)
+ *   - unorderd_set find method: O(1) on average
+ *   - unorderd_set insert method: O(1) on average
+ * 
+ * Space complexity: O(N)
+ */
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        unordered_set<int> unique_numbers;
+
+        auto it = nums.begin();
+        while (it != nums.end()) {
+            if (unique_numbers.find(*it) == unique_numbers.end()) unique_numbers.insert(*(it++));
+            else return true;
+        }
+        return false;
+    }
+};

contains-duplicate/gitsunmin.ts

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

contains-duplicate/haklee.py

@@ -0,0 +1,18 @@
+"""TC: O(n)? O(n^2)?, SC: O(n)
+
+ref: https://wiki.python.org/moin/TimeComplexity
+set는 dict와 거의 비슷하게 구현되어 있는데,
+dict의 `Set Item`의 Average Case는 O(1)이더라도
+Amortized Worst Case가 O(n)이다!
+
+즉, set에 아이템을 추가할때마다 해시 충돌이 일어날 경우
+최악의 경우 O(n^2)이 걸리므로, 아래의 set(nums)의
+TC가 O(n^2)이 되는 것일까..?
+
+set(nums)의 결과가 최악의 경우 SC가 O(n)이다.
+"""
+
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(nums) != len(set(nums))

contains-duplicate/heozeop.cpp

@@ -0,0 +1,20 @@
+// Time Complexity : O(n)
+// Spatial Complexity : O(n)
+
+#include <set>
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        set<int> count;
+
+        for(int num : nums) {
+            if (count.find(num) != count.end()) {
+                return true;
+            }
+            count.insert(num);
+        }
+
+        return false;
+    }
+};

contains-duplicate/hwanminini.js

@@ -0,0 +1,10 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+    return nums.length !== new Set(nums).size
+};

contains-duplicate/hyejjun.js

@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+
+  const set = new Set(nums);
+
+  return nums.length !== set.size ? true : false;
+
+};
+
+
+console.log(containsDuplicate([1, 2, 3, 1])); // true
+console.log(containsDuplicate([1, 2, 3, 4])); // false
+console.log(containsDuplicate([1, 1, 1, 3, 3, 4, 3, 2, 4, 2])); // true

contains-duplicate/jaejeong1.java

@@ -0,0 +1,16 @@
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+class SolutionJaeJeong1 {
+  public boolean containsDuplicate(int[] nums) {
+    // 해시맵 사용해서 같은 값의 카운트가 1보다 크면 true 반환
+    // 끝까지 다 돌면 false 반환
+    // 또는 해시셋 사용해서 모두 해시셋에 넣고
+    // 길이 비교해서 같으면 false, 다르면 true 반환
+    // 시간복잡도: O(N), 공간복잡도: O(N)
+
+    Set<Integer> set = Arrays.stream(nums).collect(HashSet::new, Set::add, Set::addAll);
+    return set.size() != nums.length;
+  }
+}