Merge branch 'DaleStudy:main' into main

Author: river20s

contains-duplicate/HISEHOONAN.swift

@@ -0,0 +1,17 @@
+//
+//  Contains_Duplicate.swift
+//  Algorithm
+//
+//  Created by 안세훈 on 3/31/25.
+//
+
+import Foundation
+
+class Solution {
+    func containsDuplicate(_ nums: [Int]) -> Bool {
+        return nums.count != Set(nums).count
+        //Set : 중복된 값을 갖지 않음.
+        //문제로 주어진 배열의 개수와 중복을 갖지않는 Set연산의 개수의 차이 비교
+        //비교 후 다르다면 true 같다면 false
+    }
+}

contains-duplicate/ayosecu.py

@@ -0,0 +1,30 @@
+from typing import List
+
+class Solution:
+    """
+        - Time Complexity: O(n), n = len(nums)
+        - Space Complexity: O(N)
+            - N = len(set_check) = The number of unique numbers
+            - If there is no duplicated numbers, N = n
+    """
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        set_check = set()
+
+        for num in nums:
+            if num in set_check:
+                return True
+            else:
+                set_check.add(num)
+        
+        return False
+
+tc = [
+        ([1, 2, 3, 1], True),
+        ([1, 2, 3, 4], False),
+        ([1,1,1,3,3,4,3,2,4,2], True)
+    ]
+
+for i, (t, e) in enumerate(tc, 1):
+    sol = Solution()
+    result = sol.containsDuplicate(t)
+    print(f"TC {i} is Passed!" if result == e else f"TC {i} is Failed! - Expected: {e}, Result: {result}")

contains-duplicate/kut7728.swift

@@ -0,0 +1,14 @@
+///  Time, Space Complexity O(N)
+
+class Solution {
+    func containsDuplicate(_ nums: [Int]) -> Bool {
+        var seen = Set<Int>()
+        for num in nums {
+            if seen.contains(num) {
+                return true
+            }
+            seen.insert(num)
+        }
+        return false
+    }
+}

house-robber/HISEHOONAN.swift

@@ -0,0 +1,27 @@
+//
+//  House_Robber .swift
+//  Algorithm
+//
+//  Created by 안세훈 on 3/31/25.
+//
+///https://leetcode.com/problems/house-robber/description/
+
+class Solution {
+    //Dynamic Programming
+    func rob(_ nums: [Int]) -> Int {
+
+        if nums.count == 1 {return nums[0]} //배열이 1개인 경우
+        if nums.count == 2 {return max(nums[0],nums[1])} //배열이 2개인 경우
+        
+        var dp = [nums[0], max(nums[0],nums[1])]
+                //제일 base가 되는 두 값을 찾는게 제일 중요함.
+                //nums[0]은 nums[1]보다 무조건 작아야함.
+        for i in 2..<nums.count{
+            dp.append(max(dp[i-2]+nums[i],dp[i-1]))
+            //dp배열의 i-2번째 배열 + nums의 i번째 배열 vs dp의 i-1번째 배열 중 큰걸 append
+            //
+        }
+        
+        return dp[dp.count-1]
+    }
+}

house-robber/ayosecu.py

@@ -0,0 +1,30 @@
+from typing import List
+
+class Solution:
+    """
+        - Time Complexity: O(n), n = len(nums)
+        - Space Complexity: O(n), n = len(nums)
+    """
+    def rob(self, nums: List[int]) -> int:
+        # DP Formation
+        # money[0] = 0
+        # money[1] = nums[0]
+        # money[i+1] = max(money[i-1] + nums[i], money[i])
+
+        money = [0] * (len(nums) + 1)
+        money[1] = nums[0]
+        for i in range(1, len(nums)):
+            money[i+1] = max(money[i-1] + nums[i], money[i])
+        
+        return money[-1]
+
+tc = [
+        ([1, 2, 3, 1], 4),
+        ([2, 7, 9, 3, 1], 12),
+        ([1, 2, 0, 5, 10], 12)
+    ]
+
+for i, (nums, e) in enumerate(tc, 1):
+    sol = Solution()
+    result = sol.rob(nums)
+    print(f"TC {i} is Passed!" if result == e else f"TC {i} is Failed! - Expected: {e}, Result: {result}")

house-robber/kut7728.swift

@@ -0,0 +1,21 @@
+class Solution {
+    func rob(_ nums: [Int]) -> Int {
+        let n = nums.count
+        if n == 0 { return 0 }
+        if n == 1 { return nums[0] }
+        if n == 2 { return max(nums[0], nums[1]) }
+
+        //dp[i]는 i번까지 고려했을 때 가능한 최대 금액
+        var dp = [Int](repeating: 0, count: n)
+        dp[0] = nums[0]
+        dp[1] = max(nums[0], nums[1])  //첫째 or 둘째 집 중 더 비싼 집 털기
+
+        //각 dp의 자리에는 바로 전 값을 그대로 가져오거나(i를 안털기), 전전집까지 턴거+i턴 값 중에서 비싼쪽 저장
+        for i in 2..<n {
+            dp[i] = max(dp[i-1], dp[i-2] + nums[i])
+        }
+
+        //마지막 집까지 고려한 최대 이익 반환하기
+        return dp[n - 1]
+    }
+}

longest-consecutive-sequence/HISEHOONAN.swift

@@ -0,0 +1,31 @@
+//
+//  Longest_Consecutive_Sequence.swift
+//  Algorithm
+//
+//  Created by 안세훈 on 3/31/25.
+//
+
+///https://leetcode.com/problems/longest-consecutive-sequence/
+
+
+class Solution {
+    func longestConsecutive(_ nums: [Int]) -> Int {
+        guard nums.count != 0 else { return 0 }
+
+        var sortednums = Array(Set(nums)).sorted() //중복제거 + 오름차순 정렬
+        var maxcount = 1 //최대 카운드
+        var count = 1 // 연산용 카운트
+
+        for i in 0..<sortednums.count - 1 {
+            if sortednums[i] == sortednums[i+1]-1 {
+                //i번째 정렬된 리스트 와 i+1번째 리스트의 값 - 1이 같을 경우
+                count += 1 //카운트에 1+
+                maxcount = max(maxcount, count) //maxcount는 연산과, max중 큰 것
+            } else {
+                count = 1  //아니면 1로 초기화.
+            }
+        }
+
+        return maxcount
+    }
+}

longest-consecutive-sequence/ayosecu.py

@@ -0,0 +1,33 @@
+from typing import List
+
+class Solution:
+    """
+        - Time Complexity: O(n), n = len(set_nums) = The number of unique numbers.
+        - Space Complexity: O(n)
+    """
+    def longestConsecutive(self, nums: List[int]) -> int:
+        set_nums = set(nums)
+        longest = 0
+
+        for num in set_nums:
+            if num - 1 not in set_nums:
+                # Only check for the start number
+                cnt = 1
+                next_num = num + 1
+                while next_num in set_nums:
+                    cnt += 1
+                    next_num += 1
+                longest = max(longest, cnt)
+        
+        return longest
+
+tc = [
+        ([100,4,200,1,3,2], 4),
+        ([0,3,7,2,5,8,4,6,0,1], 9),
+        ([1,0,1,2], 3)
+]
+
+for i, (nums, e) in enumerate(tc, 1):
+    sol = Solution()
+    result = sol.longestConsecutive(nums)
+    print(f"TC {i} is Passed!" if result == e else f"TC {i} is Failed!, Expected: {e}, Result: {result}")

longest-consecutive-sequence/kut7728.swift

@@ -0,0 +1,23 @@
+class Solution {
+    func longestConsecutive(_ nums: [Int]) -> Int {
+        let numSet = Set(nums)
+        var longest = 0
+
+        for num in numSet {
+            // 연속 수열의 시작점인지 확인
+            if !numSet.contains(num - 1) {
+                var currentNum = num
+                var currentStreak = 1
+
+                while numSet.contains(currentNum + 1) {
+                    currentNum += 1
+                    currentStreak += 1
+                }
+
+                longest = max(longest, currentStreak)
+            }
+        }
+
+        return longest
+    }
+}

top-k-frequent-elements/HISEHOONAN.swift

@@ -0,0 +1,26 @@
+//
+//  Top_K_Frequent_Elements .swift
+//  Algorithm
+//
+//  Created by 안세훈 on 3/31/25.
+//
+
+class Solution {
+    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
+        var dic : [Int : Int] = [:]
+
+        for i in nums {
+            dic[i] = dic[i , default : 0] + 1
+        }
+
+        var sortarray = dic.sorted{$0.value > $1.value}
+        var answer : [Int] = []
+
+        for i in 0..<k{
+            answer.append(sortarray[i].key)
+        }
+        print(sortarray)
+        print(answer)
+        return answer
+    }
+}