[kayden] Week 01 Solutions

contains-duplicate/kayden.py

@@ -0,0 +1,6 @@
+# 시간복잡도: O(N)
+# 공간복잡도: O(N)
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        unique_nums = set(nums)
+        return len(unique_nums) != len(nums)

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

@@ -0,0 +1,32 @@
+# 시간복잡도: O(N)
+# 공간복잡도: O(1)
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        self.result = 0
+        self.count = 0
+
+        def dfs(node):
+            if node is None:
+                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/kayden.py

@@ -0,0 +1,5 @@
+# 시간복잡도: O(log N)
+# 공간복잡도: O(log N)
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        return bin(n).count("1")

palindromic-substrings/kayden.py

@@ -0,0 +1,22 @@
+# 시간복잡도: O(N^2)
+# 공간복잡도: O(N^2)
+class Solution:
+    def countSubstrings(self, s: str) -> int:
+        n = len(s)
+        count = n
+        isPalindrome = [[False for _ in range(n)] for _ in range(n)]
+
+        for i in range(n):
+            isPalindrome[i][i] = True
+            if i < n-1 and s[i] == s[i+1]:
+                isPalindrome[i][i+1] = True
+                count += 1
+
+        for length in range(3, n + 1):
+            for i in range(n - length + 1):
+                j = i + length - 1
+                if isPalindrome[i+1][j-1] and s[i] == s[j]:
+                    isPalindrome[i][j] = True
+                    count += 1
+
+        return count

top-k-frequent-elements/kayden.py

@@ -0,0 +1,7 @@
+# 시간복잡도: O(Nlog N)
+# 공간복잡도: O(N)
+from collections import Counter
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        return [num for num, count in Counter(nums).most_common(k)]