Merge remote-tracking branch 'upstream/main'

Author: mykoo

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;
+    }
+}

missing-number/jdalma.kt

@@ -0,0 +1,41 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class `missing-number` {
+
+    fun missingNumber(nums: IntArray): Int {
+        return usingSum(nums)
+    }
+
+    /**
+     * 1. 배열을 추가로 생성하여 존재하는 정수의 인덱스에 true를 저장하여, false인 인덱스를 반환한다.
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingIndex(nums: IntArray): Int {
+        val existed = BooleanArray(nums.size + 1)
+        nums.forEach { existed[it] = true }
+
+        existed.forEachIndexed { i, e ->
+            if (!e) return i
+        }
+        return -1
+    }
+
+    /**
+     * 2. 0부터 정수 배열의 사이즈만큼 정수를 합산하여 기대하는 합산과 뺀 결과를 반환한다.
+     * TC: O(n), SC: O(1)
+     */
+    private fun usingSum(nums: IntArray): Int {
+        val size = nums.size
+        return nums.fold((size + 1) * size / 2) { acc , i -> acc - i }
+    }
+
+    @Test
+    fun `입력받은 정수 배열에서 비어있는 정수를 반환한다`() {
+        missingNumber(intArrayOf(3,2,1)) shouldBe 0
+        missingNumber(intArrayOf(3,0,1)) shouldBe 2
+        missingNumber(intArrayOf(9,6,4,2,3,5,7,0,1)) shouldBe 8
+    }
+}

missing-number/tolluset.ts

@@ -0,0 +1,21 @@
+/*
+ * TC: O(n)
+ * SC: O(1)
+ * */
+function missingNumber(nums: number[]): number {
+  const n = nums.length;
+
+  const sum = (n * (n + 1)) / 2;
+  const actualSum = nums.reduce((acc, curr) => acc + curr, 0);
+
+  return sum - actualSum;
+}
+
+const t1 = missingNumber([3, 0, 1]);
+console.info("🚀 : tolluset.ts:3: t1=", t1); // 2
+
+const t2 = missingNumber([0, 1]);
+console.info("🚀 : tolluset.ts:6: t2=", t2); // 2
+
+const t3 = missingNumber([9, 6, 4, 2, 3, 5, 7, 0, 1]);
+console.info("🚀 : tolluset.ts:9: t3=", t3); // 8