Merge branch 'main' of github.com:suhacs/leetcode-study

Author: suhacs

contains-duplicate/heypaprika.py

@@ -0,0 +1,11 @@
+# Big-O 예상 : O(n)
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        num_dict = {}
+        for num in nums:
+            if num in num_dict:
+                return True
+            else:
+                num_dict[num] = 1
+        return False
+

contains-duplicate/mike2ox.ts

@@ -0,0 +1,16 @@
+/**
+ * Source: https://leetcode.com/problems/contains-duplicate/
+ * 풀이방법: Set을 이용하여 중복된 값이 있는지 확인
+ * 시간복잡도: O(n)
+ * 공간복잡도: O(n)
+ *
+ * 생각나는 풀이방법
+ * 1. 단순하게 sorted를 이용하여 이전값과 비교하여 중복된 값이 있는지 확인
+ * 2. 정렬하지 않고 nums의 길이만큼의 배열을 만들어서 중복된 값이 있는지 저장하면서 확인
+ */
+function containsDuplicate(nums: number[]): boolean {
+  // 중복된 값이 없는 자료구조 Set 활용
+  const set = new Set<number>(nums);
+  // Set의 size와 nums의 length를 비교하여 중복된 값이 있는지 확인
+  return set.size !== nums.length;
+}

house-robber/heypaprika.py

@@ -0,0 +1,19 @@
+# Big-O 예상 : O(n)
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        a = [0] * len(nums)
+        
+        if len(nums) == 1:
+            return nums[0]
+        elif len(nums) == 2:
+            return max(nums[0], nums[1])
+            
+        a[0] = nums[0]
+        a[1] = nums[1]
+        a[2] = max(a[0] + nums[2], a[1])
+
+        for i in range(3, len(nums)):
+            a[i] = max(a[i-3], a[i-2]) + nums[i]
+
+        return max(a)
+

house-robber/mike2ox.ts

@@ -0,0 +1,25 @@
+/**
+ * Source: https://leetcode.com/problems/house-robber/
+ * 풀이방법: DP를 이용하여 집을 털 때 최대값을 구함
+ * 시간복잡도: O(n)
+ * 공간복잡도: O(n)
+ *
+ * 생각나는 풀이방법
+ */
+function rob(nums: number[]): number {
+  if (nums.length === 0) return 0;
+  if (nums.length === 1) return nums[0];
+  if (nums.length === 2) return Math.max(nums[0], nums[1]);
+
+  let prev = nums[0];
+  let maxResult = Math.max(nums[0], nums[1]);
+  let current = 0;
+
+  // 남은 집을 순회하면서 최대값을 구함
+  for (let i = 2; i < nums.length; i++) {
+    current = Math.max(maxResult, prev + nums[i]);
+    prev = maxResult;
+    maxResult = current;
+  }
+  return maxResult;
+}

longest-consecutive-sequence/heypaprika.py

@@ -0,0 +1,22 @@
+# Big-O 예상 : O(nlog(n))
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        nums = sorted(list(set(nums)))
+        if len(nums) == 0:
+            return 0
+        elif len(nums) == 1:
+            return 1
+        cur_long = 1
+        longest = 1
+        for i, num in enumerate(nums):
+            if i == 0:
+                continue
+            else:
+                if nums[i-1] + 1 == nums[i]:
+                    cur_long += 1
+                    if longest < cur_long:
+                        longest = cur_long
+                else:
+                    cur_long = 1
+        return longest
+

longest-consecutive-sequence/mike2ox.ts

@@ -0,0 +1,32 @@
+/**
+ * Source: https://leetcode.com/problems/longest-consecutive-sequence/
+ * 풀이방법: 정렬 후 순회를 통해 연속된 값이 있는지 확인
+ * 시간복잡도: O(nlogn)
+ * 공간복잡도: O(1)
+ *
+ * 생각나는 풀이방법
+ */
+
+function longestConsecutive(nums: number[]): number {
+  if (nums.length === 0) return 0;
+  const sorted = nums.sort((a, b) => a - b);
+  let prev = sorted[0];
+  let result = 1;
+  let candiResult = 1;
+
+  for (let current of sorted) {
+    if (prev === current) continue;
+    if (current === prev + 1) {
+      candiResult += 1;
+    } else {
+      if (candiResult > result) {
+        result = candiResult;
+      }
+      candiResult = 1;
+    }
+    prev = current;
+  }
+
+  if (candiResult > result) result = candiResult;
+  return result;
+}

top-k-frequent-elements/heypaprika.py

@@ -0,0 +1,16 @@
+# Big-O 예상 : O(nlog(n))
+import heapq
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+
+        num_dict = {}
+        for num in nums:
+            num_dict[num] = num_dict.get(num, 0) + 1
+        heap = []
+        for k_, v in num_dict.items():
+            heapq.heappush(heap, [-v, k_])
+        ans = []
+        for i in range(k):
+            ans.append(heapq.heappop(heap)[1])
+        return ans
+

top-k-frequent-elements/mike2ox.ts

@@ -0,0 +1,22 @@
+/**
+ * Source: https://leetcode.com/problems/top-k-frequent-elements/
+ * 풀이방법: 순회를 통해 빈도수를 저장, Object.entries를 통해 정렬하여 k개까지 반환
+ * 시간복잡도: O(nlogn)
+ * 공간복잡도: O(n)
+ *
+ * 생각나는 풀이방법
+ */
+function topKFrequent(nums: number[], k: number): number[] {
+  const KFrequentObject = new Object();
+  const result = new Array();
+  for (let num of nums) {
+    if (!Object.hasOwn(KFrequentObject, num)) KFrequentObject[num] = 0;
+    KFrequentObject[num]++;
+  }
+  // Object.entries를 통해 key, value를 배열로 반환 (포인트)
+  let sorted = Object.entries(KFrequentObject).sort((a, b) => b[1] - a[1]);
+  for (let node of sorted) {
+    result.push(parseInt(node[0]));
+  }
+  return result.slice(0, k);
+}

valid-palindrome/heypaprika.py

@@ -0,0 +1,13 @@
+# Big-O 예상 : O(n)
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        s = "".join(s.lower().split(" "))
+        new_s = ""
+        for item in s:
+            if (ord("a") <= ord(item) <= ord("z")) or (ord("0") <= ord(item) <= ord("9")):
+                new_s += item
+        output = True
+       new_s_2 = new_s[::-1]
+        return new_s_2 == new_s
+        return output
+

valid-palindrome/mike2ox.ts

@@ -0,0 +1,29 @@
+/**
+ * Source: https://leetcode.com/problems/valid-palindrome/
+ * 풀이방법: 문자열을 조건에 맞게 정제한 후 reverse하여 비교
+ * 시간복잡도: O(n)
+ * 공간복잡도: O(n)
+ *
+ * 생각나는 풀이방법
+ * 1. 정규식을 이용하여 문자열을 정제한 후 reverse하여 비교 => 정규식 작성을 못해서 배제
+ * 2. 문자열을 순회하면서 조건에 맞는 문자만 배열에 저장한 후 reverse하여 비교
+ */
+function isPalindrome(s: string): boolean {
+  // 미리 길이가 2보다 작은 경우는 true로 반환(Palindrome 조건에 맞음)
+  if (s.length < 2) return true;
+  const formatted: string[] = [];
+
+  // 문자열을 순회하면서 조건에 맞는 문자만 소문자로 변환해서 배열에 저장
+  for (let c of s) {
+    if (
+      (c >= "a" && c <= "z") ||
+      (c >= "A" && c <= "Z") ||
+      (c >= "0" && c <= "9")
+    )
+      formatted.push(c.toLowerCase());
+  }
+  // formatted 배열을 reverse하여 JSON.stringify로 비교 (중요)
+  // ? toReverse()가 chrome console에서는 작동하는데 여기서는 왜 안되는지 모르겠음
+  const reversed = [...formatted].reverse();
+  return JSON.stringify(reversed) === JSON.stringify(formatted);
+}