Merge branch 'DaleStudy:main' into main

Author: inorrni

contains-duplicate/JANGSEYEONG.js

@@ -0,0 +1,14 @@
+/*
+  시간복잡도: O(n) - new Set(nums)에서 배열 요소 순회하며 Set 생성 O(n) + 길이 비교 O(1)
+  - Set 자료구조는 중복된 값을 자동으로 제거
+*/
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  // Set으로 만들었을 때, 기존 배열과 사이즈가 다르면 중복이 제거된거임
+  const numsSet = new Set(nums);
+  return nums.length !== numsSet.size;
+};

contains-duplicate/Yn3-3xh.java

@@ -0,0 +1,27 @@
+/*
+[문제풀이]
+time: O(N), space: O(N)
+- 같은 수가 하나라도 있으면 true
+- 모든 수가 다르면 false
+
+[회고]
+ArrayList vs Set
+ArrayList: O(N^2), 매번 리스트를 처음부터 검색해야 하며, n번 반복
+Set      : O(N)  , 내부적으로 해시 테이블을 사용하여 중복 확인을 O(1)에 수행
+따라서 중복 검사에서 Set 더 효율적
+
+set.add()의 return 자료형은 boolean 이다.
+이후에는 if(!set.add()) 처럼 사용해도 좋을 듯.
+*/
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            if (set.contains(num)) {
+                return true;
+            }
+            set.add(num);
+        }
+        return false;
+    }
+}

contains-duplicate/yayyz.py

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

house-robber/JANGSEYEONG.js

@@ -0,0 +1,60 @@
+/**
+ * 시간복잡도: O(n) - 배열을 한 번만 순회
+ * 공간복잡도: O(n) - 길이가 n+1인 DP 배열 사용
+ *
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  // arr[i] = i번째 집부터 마지막 집까지 고려했을 때 훔칠 수 있는 최대 금액
+  const arr = new Array(nums.length + 1);
+
+  // 존재하지 않는 집(n+1번째)은 0, 점화식을 위한 계산용 공간임
+  arr[nums.length] = 0;
+
+  // 마지막 집만 고려하면 그 집의 금액이 최대값 (이후 집들은 없으니까 0으로 계산한 결과)
+  arr[nums.length - 1] = nums[nums.length - 1];
+
+  // 뒤에서부터 계산
+  for (let i = nums.length - 2; i >= 0; i--) {
+    // i번째 집에서의 결정:
+    // 1. i번째 집을 털고 (i+2)번째 집부터 훔치는 경우: nums[i] + arr[i+2]
+    // 2. i번째 집을 털지 않고 (i+1)번째 집부터 훔치는 경우: arr[i+1]
+    // 두 가지 중 최대값을 선택
+    arr[i] = Math.max(nums[i] + arr[i + 2], arr[i + 1]);
+  }
+
+  // arr[0]은 0번째 집부터 고려했을 때 훔칠 수 있는 최대 금액
+  return arr[0];
+};
+
+/* 풀이 설명:
+ * 문제의 핵심: 인접한 집은 연속해서 털 수 없을 때 최대로 털 수 있는 금액 찾기
+ *
+ * 접근 방식: 다이나믹 프로그래밍
+ *
+ * 1. 상태 정의:
+ *    - f(n) = n번째 집부터 마지막 집까지 고려했을 때 털 수 있는 최대 금액
+ *
+ * 2. 점화식 도출:
+ *    - 각 집마다 두 가지 선택이 있음:
+ *      1) 현재 집을 털기: 현재 집의 돈 + 두 집 이후부터의 최대 금액
+ *      2) 현재 집을 털지 않기: 다음 집부터의 최대 금액
+ *    - 따라서 점화식: f(n) = max(nums[n] + f(n+2), f(n+1))
+ *
+ * 3. 베이스 케이스:
+ *    - 존재하지 않는 집: f(n+1) = 0
+ *    - 마지막 집: f(n) = nums[n]
+ *
+ * 4. 계산 방향:
+ *    - 뒤에서부터 앞으로 계산 (Bottom-up)
+ *    - 마지막 집부터 시작해서 첫 번째 집까지 각 위치에서의 최대 금액 계산
+ *
+ * 예시 [1,2,3,1]:
+ *    - f(4) = 0 (존재하지 않는 집)
+ *    - f(3) = 1 (마지막 집)
+ *    - f(2) = max(3 + f(4), f(3)) = max(3 + 0, 1) = 3
+ *    - f(1) = max(2 + f(3), f(2)) = max(2 + 1, 3) = 3
+ *    - f(0) = max(1 + f(2), f(1)) = max(1 + 3, 3) = 4
+ *    - 결과: 4 (최적의 선택은 0번째와 2번째 집 털기)
+ */

house-robber/Yn3-3xh.java

@@ -0,0 +1,73 @@
+/*
+[문제풀이]
+(X) 주어진 nums 배열에서 index 홀수의 합과 짝수의 합을 비교해보자.
+    class Solution {
+        public int rob(int[] nums) {
+            if (nums.length == 1) {
+                return nums[0];
+            }
+
+            for (int i = 1; i <= nums.length; i++) {
+                int beforeStepIndex = i - 2;
+                if (beforeStepIndex >= 1) {
+                    nums[i - 1] += nums[beforeStepIndex - 1];
+                }
+            }
+            return Math.max(nums[nums.length - 1], nums[nums.length - 2]);
+        }
+    }
+    >> 바로 옆이 아니어도 된다.
+
+(O) 현재 num과 이전 num을 비교하여, 큰 값을 기준으로 더한다.
+time: O(N), space: O(1)
+    class Solution {
+        public int rob(int[] nums) {
+            int prevNum = 0;
+            int sum = 0;
+            for (int num : nums) {
+                int temp = Math.max(sum, prevNum + num);
+                prevNum = sum;
+                sum = temp;
+            }
+            return sum;
+        }
+    }
+    >> 공간복잡도 최적화 솔루션으로, dp 보다 직관적이지 않아, 메모리 사용이 제한되거나 입력 크기가 매우 클 때 사용하는 것이 좋을 듯
+
+time: O(N), space: O(N)
+    class Solution {
+        public int rob(int[] nums) {
+            if (nums.length == 1) {
+                return nums[0];
+            }
+
+            int[] dp = new int[nums.length];
+            dp[0] = nums[0];
+            dp[1] = Math.max(nums[0], nums[1]);
+
+            for (int i = 2; i < nums.length; i++) {
+                dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+            }
+            return dp[nums.length - 1];
+        }
+    }
+    >> 공간복잡도는 좀 더 높지만, 직관적이다.
+[회고]
+개발은 혼자하는 것이 아니기도 하고, 디버깅하기 쉽게 직관적인 DP로 푸는게 좋지 않을까?..?
+*/
+class Solution {
+    public int rob(int[] nums) {
+        if (nums.length == 1) {
+            return nums[0];
+        }
+
+        int[] dp = new int[nums.length];
+        dp[0] = nums[0];
+        dp[1] = Math.max(nums[0], nums[1]);
+
+        for (int i = 2; i < nums.length; i++) {
+            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+        }
+        return dp[nums.length - 1];
+    }
+}

house-robber/yayyz.py

@@ -0,0 +1,16 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        n = len(nums)
+        
+        if n == 1:
+            return nums[0]
+
+        dp = [0] * n
+        dp[0] = nums[0]
+        dp[1] = max(nums[0], nums[1]) 
+
+        # i 번째를 털지 않은 조건과 i번째를 털은 조건 중 max를 비교
+        for i in range(2, n):
+            dp[i] = max(dp[i-1], dp[i-2] + nums[i])
+
+        return dp[-1]

longest-consecutive-sequence/JANGSEYEONG.js

@@ -0,0 +1,26 @@
+/*
+  시간복잡도: O(n) - 모든 요소에 대해 최대 한 번씩만 검사하기 때문
+  - Set을 사용하여 O(1) 시간에 요소 존재 여부 확인 가능
+  - 각 숫자는 연속 수열의 시작점인 경우에만 while 루프를 실행
+    -> 모든 요소에 대해 while 루프의 총 반복 횟수는 전체 요소 수를 초과하지 않음
+*/
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+var longestConsecutive = function (nums) {
+  const numSet = new Set(nums);
+  let longest = 0;
+
+  for (let n of [...numSet]) {
+    if (!numSet.has(n - 1)) {
+      let length = 0;
+      while (numSet.has(n + length)) {
+        length += 1;
+      }
+      longest = Math.max(length, longest);
+    }
+  }
+  return longest;
+};

longest-consecutive-sequence/Yn3-3xh.java

@@ -0,0 +1,37 @@
+/*
+[문제풀이]
+time: O(N), space: O(N)
+- 중복 제거
+- 연속된 횟수 max 구하기
+-- 연속된 숫자 그룹 중 첫번째부터 시작되도록
+
+[회고]
+연속된 숫자 그룹 중 첫번째부터 시작되도록 하는 부분에서 막혔다..
+차분히 생각해보면 무리없이 풀 수 있지 않았을까..
+*/
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        if (nums.length == 0) {
+            return 0;
+        }
+
+        Set<Integer> numsSet = new HashSet<>();
+        for (int num : nums) {
+            numsSet.add(num);
+        }
+
+        int maxCount = 1;
+        for (int num : numsSet) {
+            if (!numsSet.contains(num - 1)) {
+                int count = 1;
+                int currentNum = num;
+                while (numsSet.contains(currentNum + 1)) {
+                    count++;
+                    currentNum++;
+                }
+                maxCount = Math.max(maxCount, count);
+            }
+        }
+        return maxCount;
+    }
+}

longest-consecutive-sequence/yayyz.py

@@ -0,0 +1,21 @@
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        if len(nums) == 0: 
+            return 0
+        
+        nums = sorted(set(nums))
+        
+        currLength = 1
+        lastNum = nums[0]
+        result = 1
+        
+        for i in range(1, len(nums)):
+            if nums[i] == lastNum + 1:
+                currLength += 1
+            else:
+                currLength = 1
+            
+            result = max(result, currLength)
+            lastNum = nums[i]
+        
+        return result

product-of-array-except-self/JANGSEYEONG.js

@@ -0,0 +1,42 @@
+/*
+  시간복잡도: O(n) - 배열을 두 번 순회하지만 여전히 선형
+  배열에서 0의 개수에 따라 결과가 달라지는 점을 이용
+  - 0이 두 개 이상: 모든 결과는 0
+  - 0이 하나: 0 위치만 전체곱, 나머지는 0
+  - 0이 없음: 전체곱 ÷ 현재 원소
+*/
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function (nums) {
+  // 0이 있는 위치들 체크용
+  const zeros = new Map();
+
+  // 전체 곱 구하기 - O(n)
+  const allProductExceptZero = nums.reduce((acc, x, i) => {
+    if (x === 0) zeros.set(i, true);
+    return x !== 0 ? acc * x : acc;
+  }, 1);
+
+  // 배열 전체 돌면서 조건에 맞게 return 시키기 - O(n)
+  return nums.map((x, i) => {
+    // 0이 2개 이상이라면 무조건 0
+    if (zeros.size > 1) {
+      return 0;
+    }
+
+    // 0이 1개일 때
+    if (zeros.size === 1) {
+      // 그게 나일 때
+      if (zeros.has(i)) return allProductExceptZero;
+
+      // 그게 다른애일 때
+      return 0;
+    }
+
+    // 0이 없을 때
+    return allProductExceptZero / x;
+  });
+};