Merge branch 'DaleStudy:main' into main

Author: kangdaia

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

best-time-to-buy-and-sell-stock/ohkingtaek.py

@@ -0,0 +1,16 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        """
+	지금까지 본 가격 중 가장 작은 값을 계속 저장하고
+        현재 가격에서 그 최소값을 뺀 값으로 최대 이익을 갱신합니다.
+        한 번 순회하면서 최대 profit을 찾는 방식입니다
+        """
+        min_price = float('inf')
+        max_profit = 0
+        
+        for price in prices:
+            min_price = min(min_price, price)
+            max_profit = max(max_profit, price - min_price)
+        
+        return max_profit
+

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/01-binary.js

@@ -0,0 +1,7 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  return nums.length !== [...new Set(nums)].length;
+};

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/OstenHun.cpp

@@ -0,0 +1,145 @@
+/*
+    Problem:
+    Given an integer array nums, 
+    return true if any value appears at least twice in the array, 
+    and return false if every element is distinct.
+
+    Input: nums = [1,2,3,1]
+    Output: true
+
+    Constraints:
+    1 <= nums.length <= 10^5
+    -10^9 <= nums[i] <= 10^9
+*/
+
+// 처음 생각한 코드
+/*
+#include <iostream>
+#include <vector>
+using namespace std;
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        for (int i = 0; i < nums.size(); i++) {
+            for (int j = i+1; j < nums.size(); j++) {
+                if (nums[i]==nums[j]) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+};
+
+int main() {
+    vector<int> arr;
+    int sz;
+    cin >> sz;
+    for (int i = 0; i < sz; i++) {
+        int nm;
+        cin >> nm;
+        arr.push_back(nm);
+    }
+
+
+    Solution s;\
+    if (s.containsDuplicate(arr))
+        cout << "true";
+    else 
+        cout << "false";
+
+    return 0;
+}
+*/
+
+// O(n^2) 시간 복잡도를 개선해보자
+/*
+    set 을 이용해서 중복이 있다면 배열의 길이가 줄어들테니
+    이를 통해 중복을 판단할 수 있다고 생각했다.
+*/
+/*
+#include <iostream>
+#include <vector>
+#include <set>
+#include <algorithm>
+using namespace std;
+
+class Solution {
+public: 
+    bool containsDuplicate(vector<int>& nums) {
+        // set과 유사하게 만들기 위해서 사용
+        sort(nums.begin(), nums.end());
+        for (size_t i = 1; i < nums.size(); i++) {
+            if (nums[i] == nums[i-1]) return true;
+        }
+        return false;
+    }
+};
+
+
+int main() {   
+    size_t sz;
+    cin >> sz;
+
+    vector<int> arr;
+    for (int i = 0; i < sz; i++) {
+        int num;
+        cin >> num;
+        arr.push_back(num);
+    }
+
+    Solution sol;
+    if (sol.containsDuplicate(arr)) {
+        cout << "true";
+    } else {
+        cout << "false";
+    }
+}
+*/
+
+// 이보다 더 좋은 방법이 있다고 gpt의 리뷰가 있었다.
+/*
+    unordered_set<int> 를 이용한다.
+    해시 테이블 자료구조를 이용하여 구현 되어 있는 것.
+    정렬은 못하지만 탐색하는데에 O(1) 이라는 장점이 있어 이를 활용한다.
+    -> 빠른 탐색 굿
+*/
+
+
+#include <iostream>
+#include <unordered_set>
+#include <vector>
+using namespace std;
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        unordered_set<int> copy_set;
+        for (int x : nums) {
+            if (copy_set.count(x)) return true;
+            copy_set.insert(x);
+        }
+        return false;
+    }
+};
+
+int main() {
+    int n;
+    cin >> n;
+
+    vector<int> nums;
+    nums.reserve(n);
+
+    for (int i = 0; i < n; i++) {
+        int x;
+        cin >> x;
+        nums.push_back(x);
+    }
+
+    Solution sol;
+    cout << (sol.containsDuplicate(nums) ? "true" : "false");
+
+    return 0;
+}

contains-duplicate/TreeStone94.py

@@ -0,0 +1,6 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        if len(set(nums)) == len(nums):
+            return False
+        else:
+            return True

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