Merge remote-tracking branch 'origin/main'

Author: haung921209

contains-duplicate/JisuuungKim.py

@@ -0,0 +1,11 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        count = {}
+
+        for i in nums:
+            if i in count:
+                return True
+            else:
+                count[i] = 1
+
+        return False

contains-duplicate/ayleeee.py

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

contains-duplicate/froggy1014.js

@@ -0,0 +1,9 @@
+// Set을 사용한 중복값 제거 후 길이 비교
+function containsDuplicate(nums) {
+  const numSet = new Set(nums);
+  return numSet.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/itschrisjang.java

@@ -0,0 +1,17 @@
+import java.util.HashSet;
+
+class Solution {
+	public boolean containsDuplicate(int[] nums) {
+		HashSet<Integer> numSet  = new HashSet<>();
+    
+		for (int i = 0; i < nums.length; i++) {
+
+			if (numSet.contains(nums[i])) {
+				return true;
+			}
+			numSet.add(nums[i]);
+		}
+    
+		return false;
+	}
+}

contains-duplicate/toychip.java

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

house-robber/froggy1014.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  if (nums.length === 0) return 0;
+  if (nums.length === 1) return nums[0];
+
+  const dp = new Array(nums.length + 1);
+  dp[0] = 0;
+  dp[1] = nums[0];
+  for (let i = 2; i < dp.length; i++) {
+    dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);
+  }
+  return dp[dp.length - 1];
+};
+
+const nums = [2, 7, 9, 3, 1];
+
+console.log(rob(nums));

longest-consecutive-sequence/froggy1014.js

@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+// 시간복잡도: O(n)
+var longestConsecutive = function (nums) {
+  let longest = 0;
+
+  let set = new Set(nums);
+
+  for (let num of nums) {
+    if (set.has(num - 1)) {
+      continue;
+    }
+
+    let count = 1;
+    let currentNum = num;
+
+    while (set.has(currentNum + 1)) {
+      count++;
+      currentNum++;
+    }
+    longest = Math.max(longest, count);
+  }
+  return longest;
+};
+
+console.log(longestConsecutive([100, 4, 200, 1, 3, 2])); // 4
+console.log(longestConsecutive([0, 3, 7, 2, 5, 8, 4, 6, 0, 1])); // 9
+console.log(longestConsecutive([1, 0, 1, 2])); // 3

top-k-frequent-elements/ayleeee.py

@@ -0,0 +1,11 @@
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        dict_map = {}
+        for a in nums:
+            if a in dict_map:
+                dict_map[a] += 1
+            else:
+                dict_map[a] = 1
+        lst = sorted(dict_map.items(), key=lambda x: x[1], reverse=True)  # 공백 수정
+        return [item[0] for item in lst[0:k]]
+        

top-k-frequent-elements/froggy1014.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function (nums, k) {
+  const map = new Map();
+  for (let n = 0; n < nums.length; n++) {
+    map.has(nums[n])
+      ? map.set(nums[n], map.get(nums[n]) + 1)
+      : map.set(nums[n], 1);
+  }
+
+  return Array.from(map.entries())
+    .sort(([key1, value1], [key2, value2]) => value2 - value1)
+    .slice(0, k)
+    .map((v) => v[0]);
+};
+
+console.log(topKFrequent([1, 1, 1, 2, 2, 3], 2));

two-sum/JisuuungKim.py

@@ -0,0 +1,12 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        d = {}
+        for i in range(len(nums)):
+            cur = nums[i]
+            x = target - cur
+            if x in d:
+                return [i, d[x]]
+            else:
+                d[cur] = i
+
+    # 시간복잡도 O(n)

two-sum/ayleeee.py

@@ -0,0 +1,6 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        for a in range(len(nums)):
+            for b in range(a+1,len(nums)):
+                if nums[a]+nums[b]==target:
+                    return [a,b]

two-sum/froggy1014.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+  let map = new Map();
+  for (let idx = 0; idx < nums.length; idx++) {
+    const rest = target - nums[idx];
+    if (map.has(rest)) {
+      return [map.get(rest), idx];
+    }
+    map.set(nums[idx], idx);
+  }
+  return [];
+};
+
+console.log(twoSum([2, 11, 15, 7], 9));

two-sum/toychip.java

@@ -0,0 +1,12 @@
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = i + 1; j < nums.length; j++) {
+                if (nums[i] + nums[j] == target) {
+                    return new int[]{i, j};
+                }
+            }
+        }
+        return null;
+    }
+}

valid-palindrome/Chapse57.py

@@ -0,0 +1,29 @@
+'''
+121 이라는 숫자의 오른족 자리숫자를 알고싶으면 
+121 %10 =으로 1이라는 숫자를 확인할수잇고
+121 /100으로 왼쪽 숫자를 확인 하는 방식으로 접근
+
+
+'''
+
+class Solution(object):
+    def isPalindrome(self, x):
+        """
+        :type x: int
+        :rtype: bool
+        """
+        if x <0: return False
+        div =1
+        while x >= 10* div:
+            div *=10
+
+        while x:
+            if x //div != x%10: return False #x //div==왼쪽숫자  x%10==오른쪽숫자
+            x= (x % div) // 10  
+            div = div/ 100
+        return True
+
+
+             
+
+