Merge branch 'DaleStudy:main' into main

Author: hyogshin

contains-duplicate/Geegong.java

@@ -0,0 +1,29 @@
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+public class Geegong {
+
+
+    /**
+     * time complexity : O(n)
+     * space complexity : o(n)
+     * @param nums
+     * @return
+     */
+    public boolean containsDuplicate(int[] nums) {
+        HashSet<Integer> uniques = new HashSet<>();
+
+        for (int num : nums) {
+            if (uniques.contains(num)) {
+                return true;
+            }
+
+            uniques.add(num);
+        }
+
+        return false;
+    }
+
+}
+

contains-duplicate/Yg-cho.js

@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+  return new Set(nums).size !== nums.length;
+};
+
+//console.log(containsDuplicate([1, 2, 3, 1])); // true
+// console.log(containsDuplicate([1, 2, 3, 4])); // false
+// console.log(containsDuplicate([1, 1, 1, 3, 3, 4, 3, 2, 4, 2])); // true

contains-duplicate/changhoon-sung.cpp

@@ -0,0 +1,33 @@
+/*
+contains-duplicate
+요구사항: 주어진 입력에서 중복된 원소가 존재하는지 여부를 참/거짓으로 반환.
+접근 1: 가장 단순한 방법은 다른 vector input_list를 두고, 입력 반복마다 전체 스캔해서 중복 여부를 체크하는 것입니다.
+        input_list의 스캔 비용 O(N)을 모든 입력에 대해 반복하므로 총 시간 복잡도는 O(N^2)입니다.
+        공간 복잡도는 입력과 같으므로 O(N)입니다.
+접근 2: 원소의 존재 여부를 더 빠르게 체크하는 방법은 set을 사용하는 것입니다.
+        set은 중복 원소를 검출하는데 효과적인 자료구조로, 내부 구현에 따라 비용과 특성이 다릅니다.
+        - C++에서 ordered_{set, map}은 정렬을 유지하는 search tree를 사용하므로 쿼리와 삽입, 삭제 비용이 평균 O(log(N))입니다.
+          search tree의 구현에 따라 최악의 경우 쿼리 비용이 O(N)까지 증가할 수 있습니다.
+        - C++에서 unordered_{set, map}은 해시 및 버킷 구조를 사용합니다. 이 경우, 평균적인 쿼리, 삽입, 삭제 비용은 O(1)입니다.
+        우리의 요구사항은 입력에 대한 별도의 정보를 저장할 필요가 없으므로 unordered_set으로 중복 검사를 수행하는 것이 비용 효율적입니다.
+        최악의 경우 모든 입력을 확인해야 합니다. N개의 입력에 대해 각각 쿼리와 입력을 수행하므로, 총 시간 복잡도는 O(N), 공간 복잡도도 입력만큼인 O(N)입니다.
+*/
+
+#include <unordered_set>
+#include <vector>
+
+class Solution {
+   public:
+    bool containsDuplicate(std::vector<int>& nums) {
+        std::unordered_set<int> s;
+
+        for (auto it = nums.begin(); it != nums.end(); it++) {
+            int x = *it;
+            if (s.find(x) != s.end())
+                return true;
+            else
+                s.insert(x);
+        }
+        return false;
+    }
+};

contains-duplicate/grapefruitgreentealoe.js

@@ -24,3 +24,23 @@ var containsDuplicate = function (nums) {
   }
   return false;
 };
+
+//25.7.23 풀이시간 10분
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+    //두번 이상 나타나는게 있으면 바로 리턴하시오. 
+    //이중 순회하게 되면 시간 초과할 예정.
+    //시간복잡도 중요. 
+    //1. 저장하는 배열을 만들고, 그 배열에 값이 있으면 리턴 false. 
+    //2.배열보다 Set을 사용한,삽입 및 조회 속도 최적화 활용하기. 
+    const container = new Set();
+    for(let i =0; i<nums.length;i++){
+        if(container.has(nums[i])) return true;
+        else container.add(nums[i])
+    }
+    return false
+};
+//위의 코드보다, 리턴을 더 빨리한다는 이점이 있다.

contains-duplicate/hi-rachel.py

@@ -0,0 +1,28 @@
+"""
+https://leetcode.com/problems/contains-duplicate/
+
+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.
+
+TC: O(n)
+SC: O(n)
+"""
+
+from typing import List
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        seen = set()
+
+        for num in nums:
+            if num in seen:
+                return True
+            else:
+                seen.add(num)
+        return False
+    
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums)) != len(nums)

contains-duplicate/minji0214.ts

@@ -0,0 +1,27 @@
+function containsDuplicate(nums: number[]): boolean {
+    let answer = false
+  for(let i = 0; i< nums.length; i ++ ){
+    if(nums.findIndex((value)=> value === nums[i]) !== i){
+        answer = true
+        break;
+     }
+    }  
+    return answer
+};
+//-> time limit 초과 오류 발생
+//시간복잡도
+// for + findIndex	O(n²) ❌
+// for + Set or Map	O(n) ✅
+//중복 여부만 체크할 때는 무조건 Set을 쓰는 게 효율적
+// includes, findIndex, indexOf는 절대 루프 안에서 쓰지 말것 — O(n²) 
+function containsDuplicate(nums: number[]): boolean {
+	const seen = new Set(); //지금까지 본 숫자들을 저장 
+	for (const num of nums) {
+		if (seen.has(num)) return true; // 중복 발견 
+		seen.add(num); // 중복이 아닐 경우 추가 
+	}
+	return false; // 중복 없음
+}
+//Set : 중복 없는 값을의 모음. 배열처럼 생겼지만, 중복을 허용하지 않음 (중복제거)
+//Map : key → value 형태로 저장하는 객체 (검색 수정)
+

house-robber/grapefruitgreentealoe.js

@@ -43,3 +43,23 @@ var rob2 = function (nums) {
 };
 //공간복잡도를 O(1)로 개선
 
+
+//7.21 풀이시간 10분 소요
+
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function(nums) {
+    const dp = new Array(nums.length+1).fill(0);
+    dp[1] = nums[0]
+    for(let i = 2; i<=nums.length;i++){
+        dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i-1])
+    }
+    return dp[nums.length]
+};
+/**
+시간복잡도 : O(n)
+공간복잡도 : O(n)
+ */

house-robber/hi-rachel.py

@@ -10,20 +10,38 @@
 # **dp[i] = max(dp[i-1], dp[i-2] + nums[i])**
 # nums 길이가 2인 경우 range(2, 2)는 for문 안 돈다.
 
+from typing import List
+
 class Solution:
     def rob(self, nums: List[int]) -> int:
-        if not nums: return 0
-        if len(nums) == 1: return nums[0]
-
+        if len(nums) == 1:
+            return nums[0]
+        
         dp = [0] * len(nums)
         dp[0] = nums[0]
         dp[1] = max(nums[0], nums[1])
 
         for i in range(2, len(nums)):
-            dp[i] = max(dp[i - 1], nums[i] + dp[i - 2])
+            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
 
         return dp[-1]
 
+"""
+공간 최적화 풀이
+
+prev2: i-2까지의 최대값 + 현재 돈
+prev1: i번째 집 안 털고, 이전까지의 최대값 유지
+
+TC: O(n)
+SC: O(1)
+"""
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        prev2, prev1 = 0, 0
+        for num in nums:
+            prev2, prev1 = prev1, max(prev1, prev2 + num)
+        return prev1 
+
 
 # TS 코드
 # function rob(nums: number[]): number {

longest-consecutive-sequence/Geegong.java

@@ -0,0 +1,49 @@
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+/**
+ * time complexity : O(n)
+ */
+public class Geegong {
+
+    public int longestConsecutive(int[] nums) {
+        HashSet<Integer> setOfNums = new HashSet<>();
+        // key : startIndex , value : length
+        Map<Integer, Integer> lengthMap = new HashMap<>();
+
+        // sort..? 를 해야될까 싶음..
+
+        // initialize
+        for (int num : nums) {
+            setOfNums.add(num);
+        }
+
+        Integer longest = 0;
+
+        for (Integer num : setOfNums) {
+            int length = iterate(setOfNums, num, 0, lengthMap);
+            longest = Math.max(longest, length);
+        }
+
+        return longest;
+    }
+
+    public Integer iterate(HashSet<Integer> hashSet, int currIndex, int currLength, Map<Integer, Integer> lengthMap) {
+        if (lengthMap.containsKey(currIndex)) {
+            return lengthMap.get(currIndex);
+        }
+
+        if (hashSet.contains(currIndex)) {
+            currLength++;
+            return iterate(hashSet, currIndex+1, currLength, lengthMap);
+
+        } else {
+            lengthMap.put(currIndex, currLength);
+            return currLength;
+        }
+
+    }
+
+}
+

longest-consecutive-sequence/Yg-cho.js

@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function(nums) {
+  if(nums.length === 0) return 0;
+
+  const numSet = new Set(nums);
+  let longest = 0;
+
+  for (const num of numSet) {
+    if(!numSet.has(num-1)) {
+      let currentNum = num;
+      let currentLength = 1;
+
+      while(numSet.has(currentNum+1)) {
+        currentNum++;
+        currentLength++;
+      }
+
+      longest = Math.max(longest, currentLength)
+    }
+  }
+  return longest;
+};