Merge branch 'main' of https://github.com/sadie100/leetcode-study

Author: sadie100

3sum/jiji-hoon96.ts

@@ -1,71 +0,0 @@
-/**
- * @param {number[]} nums
- * @return {number[][]}
- *
- * 풀이 1
- *
- * 이렇게 푸니까 시간복잡도 O(n^3) / 공간복잡도 O(n) 라서 복잡한 예시에는 time limit 이 발생함
- * 개선해보자..
- *
- * function threeSum(nums: number[]): number[][] {
- *  nums.sort((a, b) => a - b);
- *     let result = []
- *     for (let i= 0; i<nums.length; i++){
- *         for(let j= i+1 ; j <nums.length; j++){
- *             for (let k = j+1; k<nums.length; k++){
- *                 if(nums[i]+nums[j]+nums[k]===0){
- *                     result.push([nums[i], nums[j], nums[k]]);
- *                 }
- *             }
- *         }
- *     }
- *
- *     return Array.from(
- *         new Set(result.map(item => JSON.stringify(item))),
- *         str => JSON.parse(str)
- *     );
- *     }
- *
- *  풀이 2
- *
- *  투포인터를 활용해보자.
- *  아래처럼 문제를 풀게되면 시간복잡도 O(n^2) / 공간복잡도 O(1) 이다.
- *  시공간 복잡도가 줄긴하지만 메모리 사용량과 큰 숫자를 다룰 때 성능이 매우 좋다!
- */
-
-
-function threeSum(nums: number[]): number[][] {
-    let result : number[][] = []
-    nums.sort((a, b) => a - b);
-    const n = nums.length;
-
-    for(let first = 0; first<n-2; first++){
-        // 첫번째가 양수면 0이 될 수 없음
-        if(nums[first] > 0) break;
-
-        //중복된 수는 건너뜀
-        if(first > 0 && nums[first]===nums[first-1]) continue;
-
-        let left = first + 1;
-        let right = n-1;
-
-        while(left < right){
-            const sum = nums[first] +nums[left] + nums[right];
-
-            if(sum < 0){
-                left ++
-            }else if(sum > 0){
-                right --;
-            }else{
-                result.push([nums[first],nums[left],nums[right]]);
-                // left, left+1 이 같을 때 중복된 수는 건너뜀
-                while(left < right && nums[left] === nums[left+1]) left++;
-                // right, right+1 이 같을 때 중복된 수는 건너뜀
-                while(left < right && nums[right] === nums[right-1]) right--;
-                left++;
-                right--;
-            }
-        }
-    }
-    return result;
-}

best-time-to-buy-and-sell-stock/jiji-hoon96.ts

@@ -1,23 +0,0 @@
-function maxProfit(prices: number[]): number {
-  if (prices.length <= 1) return 0;
-  
-  let minPrice = prices[0];
-  let maxProfit = 0;
-  
-  for (let i = 1; i < prices.length; i++) {
-      // 현재 가격이 최소가보다 낮으면 최소가 업데이트
-      if (prices[i] < minPrice) {
-          minPrice = prices[i];
-      } 
-      // 현재 가격으로 팔았을 때의 이익 계산
-      else {
-          const currentProfit = prices[i] - minPrice;
-          // 최대 이익 업데이트
-          if (currentProfit > maxProfit) {
-              maxProfit = currentProfit;
-          }
-      }
-  }
-  
-  return maxProfit;
-}

climbing-stairs/jiji-hoon96.ts

@@ -1,37 +0,0 @@
-/**
- * @param n
- *
- * dp, 슬라이딩 윈도우 사용해서 풀 수 있다.
- *
- * 공간 복잡도를 줄이기 위해서 아래와같이 슬라이딩을 활용할 수 있다.
- *
- * function climbStairs(n: number): number {
- *     if (n <= 2) return n;
- *
- *     let first = 1;  // 1계단을 오르는 방법 수
- *     let second = 2; // 2계단을 오르는 방법 수
- *
- *     for (let i = 3; i <= n; i++) {
- *         let current = first + second;
- *         first = second;
- *         second = current;
- *     }
- *
- *     return second;
- * }
- */
-
-
-function climbStairs(n: number): number {
-    if(n <= 2) return n;
-
-    let dp: number[] = new Array(n+1);
-    dp[1] = 1;
-    dp[2] = 2;
-
-    for(let i=3;i<=n;i++){
-        dp[i] = dp[i-1] +dp[i-2];
-    }
-
-    return dp[n]
-};

combination-sum/jiji-hoon96.ts

@@ -1,49 +0,0 @@
-/**
- * 
- * @param candidates 
- * @param target 
- * 
- * backtracking 알고리즘으로 문제 해결 
- * 
- */
-
-function combinationSum(candidates: number[], target: number): number[][] {
-    const result : number[][] = [];
-    if(candidates.length === 0){
-        return result ;    
-    }
-
-    candidates.sort((a,b)=> a-b);
-
-    const validCandidates : number[] = candidates.filter(num => num <= target);
-
-    if(validCandidates.length ===0) {
-        return result;
-    }
-
-    const currentCombination : number[] = [];
-
-    function backtrack (startIndex : number, remainingTarget : number) :void {
-        if(remainingTarget === 0){
-            result.push([...currentCombination]);
-            return;
-        }
-
-        for(let i=startIndex; i<validCandidates.length; i++){
-            const currentNum = validCandidates[i];
-
-            if(currentNum > remainingTarget) {
-                break;
-            }
-            currentCombination.push(currentNum);
-
-            backtrack(i,remainingTarget - currentNum)
-
-            currentCombination.pop()            
-
-        }
-    }
-
-    backtrack(0, target);
-    return result;
-  };

contains-duplicate/Cyjin-jani.js

@@ -0,0 +1,4 @@
+const containsDuplicate = function (nums) {
+  const data = new Set(nums);
+  return data.size !== nums.length;
+};

contains-duplicate/SamTheKorean.py

@@ -0,0 +1,10 @@
+# TC : O(n) n being a length of nums array and it iterates the nums array once
+# SC : O(n) n being a size of nums array
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        seen = set()
+        for num in nums:
+            if num in seen:
+                return True
+            seen.add(num)
+        return False

contains-duplicate/YOOHYOJEONG.py

@@ -0,0 +1,8 @@
+# https://leetcode.com/problems/contains-duplicate/
+
+class Solution(object):
+    def containsDuplicate(self, nums):
+        if len(nums) > len(set(nums)):
+            return True
+        else:
+            return False

contains-duplicate/devdays9.kt

@@ -0,0 +1,6 @@
+class Solution {
+    fun containsDuplicate(nums: IntArray): Boolean {
+        val occurrences = HashSet<Int>(nums.size)
+        return nums.any { !occurrences.add(it) }
+    }
+}

contains-duplicate/gcount85.py

@@ -0,0 +1,9 @@
+# Approach : De-duplicate using Set
+# Complexity: O(n)
+# Space complexity: O(n)
+
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        dedup = set(nums)
+        return len(dedup) != len(nums)

contains-duplicate/hyeri0903.py

@@ -0,0 +1,13 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        ans = False
+        dic = dict()
+
+        for n in nums:
+            if n in dic:
+                return True
+            else:
+                dic[n] = 1
+        return ans
+
+