Merge branch 'main' of github.com:bus710/leetcode-study into week01

Author: bus710

contains-duplicate/Chaedie.py

@@ -0,0 +1,21 @@
+
+
+'''
+풀이:
+    중복된 요소가 있는지 찾는 문제입니다.
+
+    hash set 으로 중복을 제거하고
+    기존 nums 의 길이와 중복 제거된 nums_set 의 길이가 같은지 return 했습니다.
+
+시간 복잡도:
+    O(n) - has set 을 만드는 시간
+
+공간 복잡도:
+    O(n) - n개의 요소를 set에 담기 때문
+'''
+
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        nums_set = set(nums)
+        return len(nums_set) != len(nums)

contains-duplicate/dalpang81.java

@@ -0,0 +1,11 @@
+//시간복잡도 : O(nlogn)
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Arrays.sort(nums);
+        for(int i = 0; i < nums.length - 1; i++) {
+            if(nums[i] == nums[i+1])
+                return true;
+        }
+        return false;
+    }
+}

contains-duplicate/limlimjo.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+
+    // 첫 번째 방법: filter + indexOf 사용 => indexOf(),filter() 각각 시간복잡도 O(n) 두 개가 중첩이므로 시간복잡도 O(n^2)
+    // Runtime: Time Limit Exceeded 발생
+    const method1 = function() {
+            const filterNums = nums.filter((item,index) => nums.indexOf(item) !== index);
+            return filterNums.length > 0;
+    }
+
+    // 두 번째 방법: Set 사용 => nums 배열을 set으로 변환할 때 한번씩 확인하면 되므로 시간복잡도 O(n)
+    // Runtime: 14ms
+    const method2 = function() {
+        const setNums = new Set(nums);
+        return setNums.size !== nums.length;
+    }
+
+    // 위 두 가지 방법 중 Set을 사용하는 것이 성능상 훨씬 나음
+    return method2();
+};

contains-duplicate/mmyeon.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+
+/**
+ *
+ * 접근 방법
+ *  - Set 객체 사용해서 숫자 중복 제거하기
+ *  - 원본 배열과 길이 비교하기
+ *
+ * 시간복잡도 :
+ *  - 배열 순회해서 요소 Set에 삽입 : O(n)
+ *  - Set의 사이즈 크기 비교 : O(1)
+ *
+ * 공간복잡도 :
+ *  - Set에 유니크한 숫자 저장 : O(n)
+ */
+
+var containsDuplicate = function (nums) {
+  return new Set(nums).size !== nums.length;
+};

contains-duplicate/pmjuu.py

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

contains-duplicate/taewanseoul.ts

@@ -0,0 +1,21 @@
+/**
+ * 217. Contains Duplicate
+ * Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.
+ * https://leetcode.com/problems/contains-duplicate/description/
+ */
+function containsDuplicate(nums: number[]): boolean {
+  const set = new Set<number>();
+
+  for (let i = 0; i < nums.length; i++) {
+    if (set.has(nums[i])) {
+      return true;
+    }
+    set.add(nums[i]);
+  }
+
+  return false;
+}
+
+// TC: O(n)
+// https://262.ecma-international.org/15.0/index.html#sec-get-set.prototype.size
+// Set objects must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structure used in this specification is only intended to describe the required observable semantics of Set objects. It is not intended to be a viable implementation model.

house-robber/Chaedie.py

@@ -0,0 +1,103 @@
+'''
+Solution:
+    스스로 풀지 못해 학습만 진행했습니다.
+    다음 기회에 다시 풀어보도록 하겠습니다.
+'''
+class Solution:
+     def rob(self, nums: List[int]) -> int:
+        prev, curr = 0, 0
+        for num in nums:
+            prev, curr = curr, max(num + prev, curr)
+
+        return curr
+
+
+# class Solution:
+    # '''
+    # 4. 달레의 코드 풀이 - DP, prev, curr
+    # O(n) time
+    # O(1) space
+    # '''
+
+    # # 달레의 코드 풀이 - DP, prev, cur
+
+    # def rob(self, nums: List[int]) -> int:
+    #     prev, curr = 0, 0
+    #     for num in nums:
+    #         prev, curr = curr, max(num + prev, curr)
+
+    #     return curr
+
+    # '''
+    # 3. 달레의 코드 풀이 - DP
+    # [1,2,3,1]
+    # [1, 2, 3, 1]
+    # DP:[0, 1, 2, 4, 4]
+    # MAX(1 + DP[2], DP[1]) = MAX(1 + 2, 4) = 4
+    # '''
+    # # 달레의 코드 풀이 - DP
+    # # def rob(self, nums: List[int]) -> int:
+    # #     dp = [0] * (len(nums) + 1)
+    # #     dp[1] = nums[0]
+    # #     for n in range(2,len(nums) + 1):
+    # #         dp[n] = max(nums[n - 1] + dp[n - 2], dp[n - 1])
+    # #     return dp[-1]
+    # '''
+    # 2. 달레의 코드 풀이 - 재귀, 메모이제이션
+    # time: O(n)
+    # space: O(n)
+    # '''
+    # # 달레의 코드 풀이 - 재귀, 메모이제이션
+    # # def rob(self, nums: List[int]) -> int:
+    # #     memo = {}
+        
+    # #     def dfs(start):
+    # #         if start in memo:
+    # #             return memo[start]
+    # #         if not start < len(nums):
+    # #             memo[start] = 0
+    # #         else:
+    # #             memo[start] = max(nums[start] + dfs(start + 2), dfs(start + 1))
+    # #         return memo[start]
+    # #     return dfs(0)
+    # '''
+    # 1. 달레의 코드 풀이 - 재귀
+    # time: O(2^n)
+    # space: O(n)
+    
+    # F([1,2,3,1]) => MAX(1 + F([3,1], f([2,3,1])))
+    #     F([3,1]) => MAX(3 + F([]), F([1]))
+    #         F([]) => 0
+    #         F([1]) => MAX(1 + F([]), F([])) => MAX(1 + 0, 0) => 1
+    #             F([]) => 0
+    #             F([]) => 0
+    #     F([2,3,1]) => MAX(2 + F([1]), F([3,1]))
+    #         F([1]) => MAX(1 + F([]), F([])) => MAX(1 + 0, 0) => 1
+    #             F([]) => 0
+    #             F([]) => 0
+    #         F([3,1]) => MAX(3 + F([]), F([1]))
+    #         F([]) => 0
+    #         F([1]) => MAX(1 + F([]), F([])) => MAX(1 + 0, 0) => 1
+    #             F([]) => 0
+    #             F([]) => 0
+    # 재귀가 불필요하게 반복되고 있다.
+    # 메모이제이션으로 기억해두면 반복은 스킵할 수 있다.
+    # '''
+    # # 달레의 코드 풀이 - 재귀
+    # # def rob(self, nums: List[int]) -> int:
+        
+    # #     def dfs(start):
+    # #         if not start < len(nums):
+    # #             return 0
+    # #         return max(nums[start] + dfs(start + 2), dfs(start + 1))
+    # #     return dfs(0)
+        
+    # # neetcode 풀이 - DP, 이해안됨...
+    # # def rob(self, nums: List[int]) -> int:
+    # #     rob1, rob2 = 0, 0
+    # #     # [rob1, rob2, n, n+1, ...]
+    # #     for n in nums:
+    # #         temp = max(n + rob1, rob2)
+    # #         rob1 = rob2
+    # #         rob2 = temp
+    # #     return rob2

house-robber/dalpang81.java

@@ -0,0 +1,19 @@
+//시간복잡도 O(n)
+class Solution {
+    public int rob(int[] nums) {
+        if (nums.length == 1) {
+            return nums[0];
+        }
+
+        int temp2 = nums[0];
+        int temp1 = Math.max(nums[0], nums[1]);
+
+        for (int i = 2; i < nums.length; i++) {
+            int current = Math.max(temp1, nums[i] + temp2);
+            temp2 = temp1;
+            temp1 = current;
+        }
+
+        return temp1;
+    }
+}

house-robber/limlimjo.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function(nums) {
+    // 1. nums 배열 0일 때와 1일 때
+    if (nums.length === 0) return 0;
+    if (nums.length === 1) return nums[0];
+
+    // 2. i=1일 때
+    nums[1] = Math.max(nums[0], nums[1]);
+    
+    // 3. i=2일 때부터 for문 순회
+    for (let i=2; i<nums.length; i++) {
+        nums[i] = Math.max(nums[i-2] + nums[i], nums[i-1])
+    }
+    return nums[nums.length-1];
+};
+
+// 시간복잡도와 공간복잡도
+// 시간복잡도: 배열의 길이 n 만큼 for문 순회하므로 -> O(n)
+// 공간복잡도: nums 배열 그대로 수정하여 계산 -> O(1)

house-robber/mmyeon.js

@@ -0,0 +1,34 @@
+/**
+ *
+ * 접근 방법 : dp 사용
+ *  - 배열 길이가 1개 일때는 첫 번쨰 값 리턴하고, 2개면 더 큰 수를 리턴한다.
+ *  - 3개 부터는 바로 옆집 값에 현재집 값을 더한 값과 옆옆집의 값을 비교해서 큰 값을 계산한다.
+ *  - 다음 집 값에 현재까지의 값 활용하기 위해서, 바로 옆집, 옆옆집 값을 업데이트해준다.
+ *  - 현재 값이 저장된 옆집값을 리턴한다.
+ *
+ * 시간복잡도 :
+ *  - 주어진 숫자 배열 길이만큼 1회 순회하니까 O(n)
+ *
+ * 공간복잡도 :
+ *  - 옆집과 옆옆집 값을 2개의 변수에 저장해야하니까 O(1)
+ *
+ */
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  if (nums.length === 1) return nums[0];
+  if (nums.length === 2) return Math.max(nums[0], nums[1]);
+
+  let prevPrevHouse = nums[0];
+  let prevHouse = Math.max(nums[0], nums[1]);
+
+  for (let i = 2; i < nums.length; i++) {
+    const current = Math.max(prevHouse, prevPrevHouse + nums[i]);
+    prevPrevHouse = prevHouse;
+    prevHouse = current;
+  }
+
+  return prevHouse;
+};