Merge remote-tracking branch 'upstream/main'

Author: sun912

longest-common-subsequence/kayden.py

@@ -0,0 +1,17 @@
+# 시간복잡도: O(N)
+# 공간복잡도: O(N)
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        nums = set(nums)
+        answer = 0
+
+        for num in nums:
+            if num - 1 not in nums:
+                length = 1
+
+                while num + length in nums:
+                    length += 1
+
+                answer = max(answer, length)
+
+        return answer

longest-consecutive-sequence/HC-kang.ts

@@ -0,0 +1,24 @@
+/**
+ * https://leetcode.com/problems/longest-consecutive-sequence/
+ * T.C.: O(n)
+ * S.C.: O(n)
+ */
+function longestConsecutive(nums: number[]): number {
+  const numSet = new Set(nums);
+  let max = 0;
+
+  for (const num of numSet) {
+    if (numSet.has(num - 1)) {
+      continue;
+    }
+
+    let count = 0;
+    while (numSet.has(num + count)) {
+      count++;
+    }
+
+    if (count > max) max = count;
+  }
+
+  return max;
+}

longest-consecutive-sequence/gitsunmin.ts

@@ -0,0 +1,29 @@
+/**
+ * https://leetcode.com/problems/longest-consecutive-sequence
+ * time complexity : O(n)
+ * space complexity : O(n)
+ */
+const findStreak = (set: Set<number>) => (num: number): number => {
+    if (!set.has(num - 1)) return takeWhile(num, currentNum => set.has(currentNum)).length;
+    return 0;
+};
+
+const takeWhile = (start: number, predicate: (value: number) => boolean): number[] => {
+    const result: number[] = [];
+    let currentNum = start;
+    while (predicate(currentNum)) {
+        result.push(currentNum);
+        currentNum += 1;
+    }
+    return result;
+}
+
+const max = (maxStreak: number, currentStreak: number): number => Math.max(maxStreak, currentStreak);
+
+function longestConsecutive(nums: number[]): number {
+    const numSet = new Set(nums);
+
+    return [...numSet]
+        .map(findStreak(numSet))
+        .reduce(max, 0);
+}

longest-consecutive-sequence/highball.js

@@ -0,0 +1,32 @@
+//time-complexity : O(n)
+//space-complexity : O(n)
+
+const longestConsecutive = function (nums) {
+  let longest = 0;
+  const set = new Set(nums);
+
+  while (set.size > 0) {
+    let count = 0;
+    const originalSeed = set.values().next().value; //set의 첫 번째 원소 get
+
+    seed = originalSeed;
+
+    while (set.has(seed)) {
+      set.delete(seed);
+      count++;
+      seed += 1;
+    }
+
+    seed = originalSeed - 1;
+
+    while (set.has(seed)) {
+      set.delete(seed);
+      count++;
+      seed -= 1;
+    }
+
+    if (count > longest) longest = count;
+  }
+
+  return longest;
+};

longest-consecutive-sequence/jaejeong1.java

@@ -0,0 +1,46 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class SolutionLongestConsecutiveSequence {
+
+  public int longestConsecutive(int[] nums) {
+    // 정렬되지 않은 정수 nums 배열이 주어지면 가장 긴 연속 요소 시퀀스 길이를 반환
+    // O(N) 시간 내 실행되야함
+    // 전부 해시맵에 때려넣고, 키를 꺼내 연속 요소가 있는지 확인한다
+    // 연속 요소가 있으면 answer를 1 증가시키고, 연속 요소는 제거한다
+    // 시간복잡도: O(N), 공간복잡도: O(N)
+
+    Set<Integer> set = new HashSet<>();
+    for (var num : nums) {
+      set.add(num);
+    }
+    var answer = 0;
+    for (var num : nums) {
+      var length = 1;
+
+      if (set.contains(num-1)) {
+        set.remove(num);
+        var minusKey = num;
+        while (set.contains(--minusKey)) {
+          length++;
+          set.remove(minusKey);
+        }
+      }
+
+      if (set.contains(num+1)) {
+        set.remove(num);
+        var plusKey = num;
+        while (set.contains(++plusKey)) {
+          length++;
+          set.remove(plusKey);
+        }
+      }
+
+      if (length > answer) {
+        answer = length;
+      }
+    }
+
+    return answer;
+  }
+}

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/kimyoung.js

@@ -0,0 +1,24 @@
+var longestConsecutive = function (nums) { // sorting approach
+    if (!nums.length) return 0;
+    let set = new Set(nums);
+    let sorted = [...set].sort((a, b) => a - b);
+    let longestSeq = 0;
+    let currSeq = 1;
+
+    for (let i = 1; i < sorted.length; i++) { // loop through sorted list to find sequence
+        if (sorted[i - 1] + 1 === sorted[i]) {
+            currSeq++;
+        } else {
+            longestSeq = Math.max(longestSeq, currSeq); // compare sequence to figure out the longest
+            currSeq = 1;
+        }
+    }
+    
+    return Math.max(longestSeq, currSeq);
+};
+
+// time - O(nlong) using sort
+// space - O(n) store nums in set
+
+
+// TODO - try O(n) TC approach

maximum-product-subarray/HC-kang.ts

@@ -0,0 +1,26 @@
+/**
+ * https://leetcode.com/problems/maximum-product-subarray
+ * T.C. O(n)
+ * S.C. O(1)
+ * All numbers are integers, so multiplying two numbers cannot result in a smaller absolute value.
+ * It's important to pay attention to zeros and negative numbers.
+ */
+function maxProduct(nums: number[]): number {
+  if (nums.length === 0) return 0;
+
+  let max = nums[0];
+  let min = nums[0];
+  let result = nums[0];
+
+  for (let i = 1; i < nums.length; i++) {
+    const num = nums[i];
+    if (num < 0) [max, min] = [min, max];
+
+    max = Math.max(num, max * num);
+    min = Math.min(num, min * num);
+
+    result = Math.max(result, max);
+  }
+
+  return result;
+}

maximum-product-subarray/gitsunmin.ts

@@ -0,0 +1,21 @@
+/**
+ * https://leetcode.com/problems/maximum-product-subarray
+ * time complexity : O(n)
+ * space complexity : O(1)
+ */
+function maxProduct(nums: number[]): number {
+    let r = nums[0];
+    let mx = 1, mn = 1;
+
+    for (let i = 0; i < nums.length; i++) {
+        const tempMx = mx * nums[i];
+        const tempMn = mn * nums[i];
+
+        mx = Math.max(tempMx, tempMn, nums[i]);
+        mn = Math.min(tempMx, tempMn, nums[i]);
+
+        r = Math.max(r, mx);
+    }
+
+    return r;
+}