Merge branch 'DaleStudy:main' into main

Author: gitsunmin

climbing-stairs/joon.py

@@ -0,0 +1,24 @@
+from typing import Dict
+
+
+class Solution:
+    # Time: O(n)
+    # Space: O(n)
+    # ---
+    # 1. Prepare a table for caching. Initially put trivial answers for n = 1, 2.
+    # Space: O(n)
+    cacheTableOfAnswerByN: Dict[int, int] = {1: 1, 2: 2}
+
+    def climbStairs(self, n: int) -> int:
+        # 2. Use caching.
+        # Time: O(1)
+        try: return self.cacheTableOfAnswerByN[n]
+        except KeyError:
+            # 3. Simply, the answers follow Fibonacci sequence. Use recursion.
+            # O(n)
+            answerBeforeTwoSteps = self.climbStairs(n - 2)
+            # 4. Cache the answer during recursion.
+            self.cacheTableOfAnswerByN[n - 2] = answerBeforeTwoSteps
+            answerBeforeOneStep = self.climbStairs(n - 1)
+            self.cacheTableOfAnswerByN[n - 1] = answerBeforeOneStep
+            return answerBeforeTwoSteps + answerBeforeOneStep

climbing-stairs/mangodm-web.py

@@ -0,0 +1,9 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        dp = [0] * (n + 1)
+        dp[0], dp[1] = 1, 1
+
+        for i in range(2, n + 1):
+            dp[i] = dp[i - 1] + dp[i - 2]
+
+        return dp[n]

combination-sum/joon.py

@@ -0,0 +1,34 @@
+from typing import List
+from typing import Set
+from typing import Tuple
+
+
+class Solution:
+    target: int
+    candidates: List[int]
+    answers: Set[Tuple[int]]
+
+    # Time: O(k^N)
+    # Space: O(N^2)
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        self.target = target
+        self.candidates = candidates
+        self.answers = set()
+        self.findAnswers(0, [])
+        return list(self.answers)
+
+    def findAnswers(self, currentSum: int, nums: List[int]):
+        assert currentSum < self.target, "Given sum should be smaller than the target."
+        for num in self.candidates:
+            if currentSum + num < self.target:
+                # 1. Continue finding.
+                # Time: O(k^N)
+                # Space: O(N^2). Max total size of all "nums" = 1 + 2 + ... + N.
+                self.findAnswers(currentSum + num, nums + [num])
+            if currentSum + num > self.target:
+                # 2. Stop finding.
+                continue
+            if currentSum + num == self.target:
+                # 3. Add the answer.
+                self.answers.add(tuple(sorted(list(nums + [num]))))
+        return

longest-consecutive-sequence/TonyKim9401.java

@@ -0,0 +1,21 @@
+// TC: O(n)
+// SC: O(n)
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        int output = 0;
+        Set<Integer> set = new HashSet<>();
+
+        for (int num : nums) set.add(num);
+
+        for (int num : nums) {
+            int count = 1;
+            if (!set.contains(num - count)){
+                while (set.contains(num + count)) {
+                    count += 1;
+                }
+            }
+            output = Math.max(output, count);
+        }
+        return output;
+    }
+}

longest-consecutive-sequence/jdalma.kt

@@ -0,0 +1,113 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import kotlin.math.max
+
+class `longest-consecutive-sequence` {
+    fun longestConsecutive(nums: IntArray): Int {
+        if (nums.isEmpty()) return 0
+        return usingUnionFind(nums)
+    }
+
+    /**
+     * 1. 배열을 정렬하여 순서대로 순회하며 연속 수열 길이를 확인한다.
+     * TC: O(n * log(n)), SC: O(1)
+     */
+    private fun usingSort(nums: IntArray): Int {
+        nums.sort()
+
+        var (length, maxLength) = 1 to 0
+        for (index in 0 until nums.size - 1) {
+            if (nums[index] == nums[index + 1]) {
+                continue
+            } else if (nums[index] + 1 == nums[index + 1]) {
+                length++
+            } else {
+                maxLength = max(length, maxLength)
+                length = 1
+            }
+        }
+        return max(length, maxLength)
+    }
+
+    /**
+     * 2. Set의 자료구조를 활용하여 가장 작은 값부터 while문을 통한 최대 증가 값을 반환한다.
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingSet(nums: IntArray): Int {
+        val numberSet = nums.toSet()
+        var maxLength = 0
+
+        for (number in nums) {
+            if (numberSet.contains(number - 1)) {
+                continue
+            }
+            var length = 1
+            while (numberSet.contains(number + length)) {
+                length++
+            }
+            maxLength = max(maxLength, length)
+        }
+
+        return maxLength
+    }
+
+    /**
+     * 3. Union-Find
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingUnionFind(nums: IntArray): Int {
+        val nodes = mutableMapOf<Int, Int>()
+        val dsu = DSU(nums.size)
+
+        for ((i,n) in nums.withIndex()) {
+            if (n in nodes) continue
+
+            nodes[n - 1]?.let { dsu.union(i, it) }
+            nodes[n + 1]?.let { dsu.union(i, it) }
+
+            nodes[n] = i
+        }
+
+        return dsu.maxLength()
+    }
+
+    @Test
+    fun `입력받은 정수 배열의 최대 연속 수열 길이를 반환한다`() {
+        longestConsecutive(intArrayOf()) shouldBe 0
+        longestConsecutive(intArrayOf(100,4,200,1,3,2)) shouldBe 4
+        longestConsecutive(intArrayOf(11,23,12,13,14,21)) shouldBe 4
+        longestConsecutive(intArrayOf(0,3,7,2,5,8,4,6,0,1)) shouldBe 9
+        longestConsecutive(intArrayOf(11,64,43,12,13,10,9,8,7)) shouldBe 7
+    }
+}
+
+class DSU(val n: Int) {
+    private val parent = IntArray(n) { it }
+    private val size = IntArray(n) { 1 }
+
+    private fun find(x: Int): Int {
+        if (parent[x] != x)
+            parent[x] = find(parent[x])
+        return parent[x]
+    }
+
+    fun union(x: Int, y: Int) {
+        val root = find(x)
+        val child = find(y)
+        if(root != child) {
+            parent[child] = root
+            size[root] += size[child]
+        }
+    }
+
+    fun maxLength(): Int {
+        var res = 0
+        for (i in parent.indices) {
+            if (parent[i] == i)
+                res = maxOf(res, size[i])
+        }
+        return res
+    }
+}

longest-consecutive-sequence/tolluset.ts

@@ -0,0 +1,42 @@
+/*
+ * TC: O(n)
+ * SC: O(n)
+ * */
+function longestConsecutive(nums: number[]): number {
+  const n = nums.length;
+
+  if (n <= 1) {
+    return n;
+  }
+
+  const numsSet = new Set(nums);
+  let longestLen = 0;
+
+  for (let i = 0; i < n; i++) {
+    let current = nums[i];
+
+    if (!numsSet.has(current - 1)) {
+      let currentLen = 1;
+
+      while (numsSet.has(current + 1)) {
+        current++;
+        currentLen++;
+      }
+
+      longestLen = Math.max(longestLen, currentLen);
+    }
+  }
+  return longestLen;
+}
+
+const t1 = longestConsecutive([100, 4, 200, 1, 3, 2]);
+console.info("🚀 : tolluset.ts:5: t1=", t1); // 4
+
+const t2 = longestConsecutive([0, 3, 7, 2, 5, 8, 4, 6, 0, 1]);
+console.info("🚀 : tolluset.ts:8: t2=", t2); // 9
+
+const t3 = longestConsecutive([9, 1, 4, 7, 3, -1, 0, 5, 8, -1, 6]);
+console.info("🚀 : tolluset.ts:40: t3=", t3); // 7
+
+const t4 = longestConsecutive([-6, -1, -1, 9, -8, -6, -6, 4, 4, -3, -8, -1]);
+console.info("🚀 : tolluset.ts:59: t4=", t4); // 1

maximum-product-subarray/TonyKim9401.java

@@ -0,0 +1,24 @@
+// TC: O(n)
+// SC: O(1)
+class Solution {
+    public int maxProduct(int[] nums) {
+        int currentMax = nums[0];
+        int currentMin = nums[0];
+        int maxProduct = nums[0];
+
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] < 0) {
+                int temp = currentMax;
+                currentMax = currentMin;
+                currentMin = temp;
+            }
+
+            currentMax = Math.max(nums[i], currentMax * nums[i]);
+            currentMin = Math.min(nums[i], currentMin * nums[i]);
+
+            maxProduct = Math.max(maxProduct, currentMax);
+        }
+
+        return maxProduct;
+    }
+}

maximum-product-subarray/jdalma.kt

@@ -0,0 +1,56 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import kotlin.math.max
+import kotlin.math.min
+
+class `maximum-product-subarray` {
+
+    fun maxProduct(nums: IntArray): Int {
+        return usingOptimizedDP(nums)
+    }
+
+    /**
+     * 현재의 값, 이전 위치의 최대 누적곱, 이전 위치의 최소 누적곱 이 세 개를 비교하여 한 번의 순회로 최대 값을 반환한다.
+     * 음수와 음수가 곱해져 최대 값이 도출될 수 있기에 DP 배열을 두 개 생성한다.
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingDP(nums: IntArray): Int {
+        val (min, max) = IntArray(nums.size) { 11 }.apply { this[0] = nums[0] } to IntArray(nums.size) { -11 }.apply { this[0] = nums[0] }
+        var result = nums[0]
+        for (index in 1 until nums.size) {
+            max[index] = max(max(nums[index], nums[index] * max[index - 1]), nums[index] * min[index - 1])
+            min[index] = min(min(nums[index], nums[index] * max[index - 1]), nums[index] * min[index - 1])
+            result = max(max(min[index], max[index]), result)
+        }
+
+        return result
+    }
+
+    /**
+     * DP 배열이 입력받는 정수의 배열만큼 생성할 필요가 없고, 이전 값과 현재 값만 기억하면 되므로 공간복잡도가 개선되었다.
+     * TC: O(n), SC: O(1)
+     */
+    private fun usingOptimizedDP(nums: IntArray): Int {
+        var (min, max) = nums[0] to nums[0]
+        var result = nums[0]
+        for (index in 1 until nums.size) {
+            val (tmpMin, tmpMax) = min to max
+            max = max(max(nums[index], nums[index] * tmpMax), nums[index] * tmpMin)
+            min = min(min(nums[index], nums[index] * tmpMax), nums[index] * tmpMin)
+            result = max(max(min, max), result)
+        }
+
+        return result
+    }
+
+    @Test
+    fun `입력받은 정수 배열의 가장 큰 곱을 반환한다`() {
+        maxProduct(intArrayOf(2,3,-2,4)) shouldBe 6
+        maxProduct(intArrayOf(-2,0,-1)) shouldBe 0
+        maxProduct(intArrayOf(-10)) shouldBe -10
+        maxProduct(intArrayOf(-2,3,-4)) shouldBe 24
+        maxProduct(intArrayOf(-4,-3,-2)) shouldBe 12
+    }
+}

maximum-subarray/tolluset.ts

@@ -0,0 +1,39 @@
+/*
+ * TC: O(n)
+ * SC: O(1)
+ * */
+function maxProduct(nums: number[]): number {
+  const n = nums.length;
+
+  if (n === 1) {
+    return nums[0];
+  }
+
+  let max = 0,
+    min = 0,
+    res = 0;
+
+  for (let i = 0; i < n; i++) {
+    const cur = nums[i];
+
+    if (cur < 0) {
+      [max, min] = [min, max];
+    }
+
+    max = Math.max(cur, max * cur);
+    min = Math.min(cur, min * cur);
+
+    res = Math.max(res, max);
+  }
+
+  return res;
+}
+
+const t1 = maxProduct([2, 3, -2, 4]);
+console.info("🚀 : tolluset.ts:3: t1=", t1); // 6
+
+const t2 = maxProduct([-2, 0, -1]);
+console.info("🚀 : tolluset.ts:6: t2=", t2); // 0
+
+const t3 = maxProduct([-2]);
+console.info("🚀 : tolluset.ts:34: t3=", t3); // -2

missing-number/TonyKim9401.java

@@ -0,0 +1,15 @@
+// TC: O(n)
+// -> add all nums into set
+// SC: O(n)
+// -> set contains all nums' elements
+class Solution {
+    public int missingNumber(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) set.add(num);
+
+        int output = 0;
+        while (set.contains(output)) output += 1;
+
+        return output;
+    }
+}