Merge remote-tracking branch 'upstream/main'

Author: mykoo

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

maximum-product-subarray/highball.js

@@ -0,0 +1,84 @@
+//time-complexity : O(n)
+//space-complexity : O(n)
+
+const maxProduct = function (nums) {
+  let subarrays = [];
+  let subarray = [];
+  let zeroCount = 0;
+
+  /* -------------------------------------------------------------------------- */
+  /*                     nonzero subarray 잘라서 subarrays에 넣기                  */
+  /* -------------------------------------------------------------------------- */
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] === 0) {
+      if (subarray.length > 0) {
+        subarrays.push([...subarray]);
+        subarray.length = 0; //각 element의 metadata를 garbage collection에 들어가야 하는 것으로 marking할 뿐이므로 O(1)!
+      }
+      zeroCount++;
+      continue;
+    }
+    subarray.push(nums[i]);
+  }
+  if (subarray.length > 0) {
+    subarrays.push([...subarray]);
+  }
+
+  /* -------------------------------------------------------------------------- */
+  /*                   각 subarray의 maxProduct들 중 최대값 리턴하기                  */
+  /* -------------------------------------------------------------------------- */
+  if (zeroCount === 0) {
+    return maxProductNonzero(nums);
+  } else {
+    let max = 0;
+    for (let i = 0; i < subarrays.length; i++) {
+      max = Math.max(maxProductNonzero(subarrays[i]), max);
+    }
+    return max;
+  }
+};
+
+const maxProductNonzero = function (nonZeroNums) {
+  if (nonZeroNums.length === 1) return nonZeroNums[0]; //firstNegativeIndex = lastNegativeIndex = 0이 되어 버려서 frontProduct와 backProduct 중 어느 것도 계산이 안 돼버리므로 early return으로 처리.
+
+  let firstNegativeIndex = -1;
+  let lastNegativeIndex = -1;
+  let negativeCount = 0;
+  for (let i = 0; i < nonZeroNums.length; i++) {
+    if (nonZeroNums[i] < 0 && firstNegativeIndex !== lastNegativeIndex) {
+      lastNegativeIndex = i;
+      negativeCount++;
+    }
+    if (nonZeroNums[i] < 0 && firstNegativeIndex === lastNegativeIndex) {
+      firstNegativeIndex = i;
+      negativeCount++;
+    }
+  }
+
+  if (negativeCount === 1) {
+    lastNegativeIndex = firstNegativeIndex;
+  }
+
+  if (negativeCount % 2 === 0) {
+    /* -------------------------------------------------------------------------- */
+    /*                     음수 개수가 짝수 개면 그냥 전체 곱한 게 최대값임                  */
+    /* -------------------------------------------------------------------------- */
+    let product = 1;
+    for (let i = 0; i < nonZeroNums.length; i++) {
+      product *= nonZeroNums[i];
+    }
+    return product;
+  } else {
+    /* -------------------------------------------------------------------------- */
+    /*        음수 개수가 홀수 개면 처음부터 lastNegativeIndex 직전까지 곱한 수 혹은          */
+    /*        firstNegativeIndex부터 끝까지 곱한 수 중 하나가 최대값임                     */
+    /* -------------------------------------------------------------------------- */
+    let frontProduct = 1;
+    let backProduct = 1;
+    for (let i = 0; i < nonZeroNums.length; i++) {
+      if (i < lastNegativeIndex) frontProduct *= nonZeroNums[i];
+      if (i > firstNegativeIndex) backProduct *= nonZeroNums[i];
+    }
+    return Math.max(frontProduct, backProduct);
+  }
+};

maximum-product-subarray/kayden.py

@@ -0,0 +1,33 @@
+# 시간복잡도: O(N)
+# 공간복잡도: O(1)
+class Solution:
+    def maxProduct(self, nums: List[int]) -> int:
+        n = len(nums)
+        positive, negative = 0, 0
+
+        if nums[0] > 0:
+            positive = nums[0]
+        else:
+            negative = nums[0]
+
+        answer = max(nums)
+
+        for i in range(1, n):
+            if nums[i] >= 0:
+                positive *= nums[i]
+                negative *= nums[i]
+
+                if positive == 0:
+                    positive = nums[i]
+
+            else:
+                temp = positive
+                positive = negative * nums[i]
+                negative = temp * nums[i]
+
+                if negative == 0:
+                    negative = nums[i]
+
+            answer = max(answer, positive)
+
+        return answer