Merge branch 'DaleStudy:main' into main

contains-duplicate/HerrineKim.js

@@ -0,0 +1,17 @@
+// 시간복잡도: O(n)
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  const seen = new Set();
+  for (let num of nums) {
+    if (seen.has(num)) {
+      return true; // 중복 발견
+    }
+    seen.add(num);
+  }
+  return false; // 모든 요소가 고유
+};
+

contains-duplicate/HodaeSsi.py

@@ -0,0 +1,11 @@
+from typing import List
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        dict = {}
+        for num in nums:
+            dict[num] = dict.get(num, 0) + 1
+            if dict[num] > 1:
+                return True
+        return False
+

contains-duplicate/Jay-Mo-99.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def containsDuplicate(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: bool
+        """
+        #해석
+        #sets는 복수 요소를 허용하지 않는다(sets don't allow duplicate elements.)
+        #만약 set에 기반된 list가 기존 nums와 길이가 다르다면 duplicate element가 있었다는 뜻이다. 
+        #If the length of the set created from nums is different from the original list(nums), It means there are duplicates. 
+
+        #Big O
+        #N: 주어진 배열 nums의 길이(Length of the input list nums)
+
+        #Time Complexity: O(N)
+        #- set은 nums의 길이 n에 기반하여 생성된다(Creating a set from nums): O(N)
+        #- 생성된 list와 기존 nums와의 비교는 상수(Comparing the lengths between created list and original list) : O(1)
+
+        #Space Complexity: O(N)
+        #-set은 nums의 길이에 의해 생성되므로 n에 영향받음(The set requires extra space depends on the size of nums) : O(N) 
+        return len(list(set(nums))) != len(nums) #set된 list와 기존 nums의 len이 일치하지 않는다면 true(duplicate), 아니면 false
+
+

contains-duplicate/Real-Reason.kt

@@ -0,0 +1,10 @@
+package leetcode_study
+
+class SolutionContainsDuplicate {
+    fun containsDuplicate(nums: IntArray): Boolean {
+        val size = nums.size
+        val numsToSet = nums.toSet()
+
+        return size != numsToSet.size
+    }
+}

contains-duplicate/YeomChaeeun.ts

@@ -0,0 +1,36 @@
+function containsDuplicate(nums: number[]): boolean {
+
+    // 접근 (1) - 시간 복잡도가 매우 커서 실패
+    // const uniqueArr = nums.filter((item, index) => { return nums.indexOf(item) === index })
+    // console.log(uniqueArr)
+    //
+    // return nums.length !== uniqueArr.length;
+
+    // 접근 (2) - 양 옆의 값을 비교 =============
+    // if(nums.length === 1)
+    //     return false;
+    //
+    // // 정렬
+    // nums.sort()
+    //
+    // // 양 옆의 값을 비교
+    // for(let i = 0; i < nums.length; i++){
+    //     console.log(nums[i], nums[i+1])
+    //     if(nums[i] === nums[i+1]){
+    //         return true;
+    //     }
+    // }
+    // return false;
+
+    // 접근 (3) - obj를 이용 ================
+    let obj={}
+
+    for(let i = 0; i < nums.length; i++) {
+        if(obj[nums[i]]) {
+            return true;
+        }
+        obj[nums[i]] = 1;
+    }
+    return false;
+
+};

contains-duplicate/aa601.c

@@ -0,0 +1,60 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+void	merge(int *nums, int left, int mid, int right)
+{
+	int	i;
+	int	j;
+	int	k;
+	int	leftArr[mid - left + 1];
+	int	rightArr[right - mid];
+
+	i = -1;
+	while (++i < mid - left + 1) // 왼쪽 분할된 부분 넣기
+		leftArr[i] = nums[left + i];
+	i = -1;
+	while (++i < right - mid) // 오른쪽 분할된 부분 넣기
+		rightArr[i] = nums[mid + i + 1];
+	i = 0;
+	j = 0;
+	k = left; // **** nums배열인덱스 => left부터 시작
+	// 나누어진 배열끼리 비교해서 nums배열 재배치
+	while ((i < mid - left + 1) && (j < right - mid)) {
+		if (leftArr[i] <= rightArr[j])
+			nums[k] = leftArr[i++];
+		else
+			nums[k] = rightArr[j++];
+		++k;
+	}
+	while (i < mid - left + 1) // left배열 남아있으면 마저 삽입
+		nums[k++] = leftArr[i++];
+	while (j < right - mid) // right배열 남아있으면 마저 삽입
+		nums[k++] = rightArr[j++];
+}
+
+void	mergeSort(int *nums, int left, int right) {
+	int	mid;
+
+	if (left < right)
+	{
+		mid = (left + right) / 2;
+		mergeSort(nums, left, mid); // 왼쪽분할
+		mergeSort(nums, mid + 1, right); // 오른쪽분할
+		merge(nums, left, mid, right);
+	}
+}
+
+bool containsDuplicate(int* nums, int numsSize) {
+	int	i;
+
+	mergeSort(nums, 0, numsSize - 1);
+	i = -1;
+	while (++i + 1 < numsSize) {
+		if (nums[i] == nums[i + 1])
+			return (true);
+	}
+	return (false);
+}
+
+
+

contains-duplicate/donghyeon95.java

@@ -0,0 +1,31 @@
+import java.util.*;
+
+class Solution {
+	public boolean containsDuplicate(int[] nums) {
+		/*
+		* -- 풀이 --
+		* nums를 순회하면서 HashSet에 데이터를 넣어서 중복되었는 지 확인한다.
+		*
+		* -- 시간 복잡도 --
+		* 길이 N인 nums를 순환하는데 대한 시간 복잡도 => O(N)
+		* hashSet의 add에 대한 시간 복잡도 => O(1)
+		* 전체 시간 복잡도 O(1)*O(N) =O(n)
+		* ------------------------------------------
+		*
+		* -- 공간 복잡도 --
+		* 길이 N인 nums를 넣을 Hashset이 있어야 하기에 O(N)
+		* -------------------------------------------
+		*/
+
+		// 중복을 확인할 수 있는 set 선언
+		HashSet<Integer> hashSet = new HashSet<>();
+
+		for (int num: nums) {
+			// set에 있다면
+			if (!hashSet.add(num)) return true;
+		}
+
+		return false;
+	}
+}
+

contains-duplicate/higeuni.js

@@ -0,0 +1,10 @@
+// 풀이
+// Set으로 중복 제거 후 nums와 길이 비교
+
+// TC : O(N)
+// SC : O(N)
+
+var containsDuplicate = function(nums) {
+  return new Set(nums).size !== nums.length
+};
+

contains-duplicate/imsosleepy.java

@@ -0,0 +1,15 @@
+// 중복제거를 위해 set을 적극적으로 활용해야할 듯...
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> numSet = new HashSet<>();
+
+        for (int num : nums) {
+            if (numSet.contains(num)) {
+                return true;
+            }
+            numSet.add(num);
+        }
+
+        return false;
+    }
+}

contains-duplicate/jungsiroo.py

@@ -0,0 +1,18 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        # Slow - tc : O(n) / sc : O(1)
+
+        """return len(set(nums)) != len(nums)"""
+
+        # Fast - tc : O(n) / sc : O(n)
+        check = set()
+
+        for num in nums:
+            if num in check:
+                return True
+            check.add(num)
+
+        return False
+
+
+

contains-duplicate/kdh-92.java

@@ -0,0 +1,35 @@
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        /**
+         * Constraints
+         * - 1 <= nums[] <= 10^5
+         * - -10^9 <= nums[i] <= 10^9
+         *
+         * Output
+         * - true : 중복 값 존재
+         * - false : 모든 값이 유일
+         */
+
+        // 해결법 1 (HashMap 방식 - HashSet 유사)
+        // 시간복잡도: O(N), 공간 복잡도 : O(N)
+        Map<Integer, Integer> countMap = new HashMap<>();
+
+         for (int num: nums) {
+             int count = countMap.getOrDefault(num, 0) + 1;
+             if (count > 1) return true;
+             countMap.put(num, count);
+         }
+
+         return false;
+
+        // 해결법 2 (정렬)
+        // 시간 복잡도 : O(N log N), 공간 복잡도 : O(1)
+         Arrays.sort(nums);
+
+         for (int i = 0; i < nums.length - 1; i++) {
+             if (nums[i] == nums[i + 1]) return true;
+         }
+
+         return false;
+    }
+}

contains-duplicate/o-ddong.py

@@ -0,0 +1,3 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(nums) != len(set(nums))

contains-duplicate/oyeong011.cpp

@@ -0,0 +1,14 @@
+#include<bits/stdc++.h>
+using namespace std;
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        unordered_map<int, int> mp;
+        for(int a : nums){
+            if(++mp[a] >= 2){
+                return true;
+            }
+        }
+        return false;
+    }
+};

contains-duplicate/river20s.java

@@ -0,0 +1,16 @@
+import java.util.HashSet;
+
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        HashSet<Integer> set = new HashSet<>();
+
+        for (int num : nums) {
+		        if (!set.add(num)) {
+				        return true;
+		        }
+		    }
+
+		return false;
+    }
+}
+

house-robber/HerrineKim.js

@@ -0,0 +1,25 @@
+// 시간복잡도: O(n)
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  const n = nums.length;
+  if (n === 0) return 0;
+  if (n === 1) return nums[0];
+
+  // DP 배열 초기화
+  let prev2 = 0; // dp[i-2]
+  let prev1 = 0; // dp[i-1]
+
+  // 최대 수익 계산
+  for (let num of nums) {
+    const current = Math.max(prev1, prev2 + num);
+    prev2 = prev1;
+    prev1 = current;
+  }
+
+  return prev1;
+};
+

house-robber/HodaeSsi.py

@@ -0,0 +1,15 @@
+from typing import List
+
+
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        dp = [0] * len(nums)
+
+        for i in range(len(nums)-1, -1, -1):
+            dpMax = 0
+            for j in range(i + 2, len(nums)):
+                dpMax = max(dpMax, dp[j])
+            dp[i] = nums[i] + dpMax
+
+        return max(dp)
+

house-robber/Jay-Mo-99.py

@@ -0,0 +1,37 @@
+# --- 해석 ---
+#매개변수 nums 를 순회하면서 nums[i] 일때의 최대 누적값을 업데이트 한다
+#prev1은 현재까지의 최고 누적금액, prev2는 이전 집까지의 최고 누적금액이다. 
+#현재 집 nums[i] 를 도둑질 하려면, 이전 집까지의 최고금액(prev2) + 현재 집(nums[i])이다.
+#현재 집 nums[i]를 도둑질에 제외하려면 현재까지의 최고 금엑(prev1) 이다. 
+#loop 당 저 둘의 최댓값을 선택하여 current변수에 update해준다. 
+
+# --- Big O
+#N: 매개변수 nums의 길이가 N이다. 
+
+# Time Complexity: O(N)
+#- for loop 는 nums[0] 부터 nums[len(nums)]만큼 순회: O(N)
+
+# Space Complexity: O(1)
+#-current,prev1,prev2 는 nums와 무관한 상수 메로리 할당: O(1)
+
+
+class Solution(object):
+    def rob(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        #prev1: 현재 집까지의 최고 금액
+        #prev2: 이이전 집까지의 최고 금액 
+        prev1,prev2=0,0
+
+        for num in nums:
+            #current는 prev1과 prev2+num 중 큰 값을 update
+            current = max(prev1,prev2+num)
+            prev2 = prev1 #current업데이트 이후 prev1(현재 최고금액) 이 prev2(이어진 집까지 최고금액)가된다
+            prev1= current #prev1은 현 num까지 고려된 current의 값이다. (현재 최고 금액액)
+        return prev1
+nums = [2,7,9,3,1]
+solution = Solution()
+solution.rob(nums)
+