Merge branch 'DaleStudy:main' into main

Author: gitsunmin

longest-substring-without-repeating-characters/EGON.py

@@ -0,0 +1,80 @@
+from unittest import TestCase, main
+
+
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        return self.solve_sliding_window(s)
+
+    """
+    Runtime: 313 ms (Beats 8.97%)
+    Time Complexity:
+        - left가 0에서 len(s)까지 조회, right가 left + 1 부터 len(s)까지 조회하므로 O(n * (n + 1) / 2)
+            - left가 조회할 때마다, 2항 max 연산하므로 * 2
+        > O((n * (n + 1) / 2) * 2) ~= O(n ^ 2)
+
+    Memory: 16.51 (Beats 81.63%)
+    Space Complexity: O(n)
+        > checker가 최대 s의 길이만큼 커질 수 있으므로 O(n), upper bound
+    """
+    def solve_two_pointer(self, s: str) -> int:
+        if not s:
+            return 0
+
+        max_length = 1
+        for left in range(len(s)):
+            if len(s) - left + 1 < max_length:
+                return max_length
+
+            right = left + 1
+            checker = set(s[left])
+            while right < len(s):
+                if s[right] in checker:
+                    break
+
+                checker.add(s[right])
+                right += 1
+
+            max_length = max(max_length, len(checker))
+
+        return max_length
+
+    """
+    Runtime: 58 ms (Beats 46.47%)
+    Time Complexity:
+        - 중복 검사는 set을 사용하므로 O(1)
+        - right가 len(s)까지 조회하므로 O(n)
+            - right가 조회한 뒤 2항 max 연산하는데 O(2)
+        - left가 최대 right까지 조회하고 right < len(s) 이므로 O(n), upper bound
+        > O(n) * O(2) + O(n) ~= O(n)
+
+    Memory: 16.60 (Beats 41.73%)
+    Space Complexity: O(n)
+        > checker가 최대 s의 길이만큼 커질 수 있으므로 O(n), upper bound
+    """
+    def solve_sliding_window(self, s: str) -> int:
+        max_length = 0
+        left = right = 0
+        checker = set()
+        while left < len(s) and right < len(s):
+            while right < len(s) and s[right] not in checker:
+                checker.add(s[right])
+                right += 1
+
+            max_length = max(max_length, len(checker))
+
+            while left < len(s) and (right < len(s) and s[right] in checker):
+                checker.remove(s[left])
+                left += 1
+
+        return max_length
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        s = "pwwkew"
+        output = 3
+        self.assertEqual(Solution.lengthOfLongestSubstring(Solution(), s), output)
+
+
+if __name__ == '__main__':
+    main()

longest-substring-without-repeating-characters/TonyKim9401.java

@@ -0,0 +1,25 @@
+// TC: O(n^2)
+// -> all elements can be retrived multiple times in the worst case
+// SC: O(1)
+// -> since declare, no more increase or decrease
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        int max = 0;
+        int count = 0;
+        boolean[] checkList = new boolean[128];
+
+        for (int i = 0; i < s.length(); i++) {
+            int idx = s.charAt(i);
+            if (checkList[idx]) {
+                max = Math.max(max, count);
+                i -= count;
+                count = 0;
+                checkList = new boolean[128];
+            } else {
+                count += 1;
+                checkList[idx] = true;
+            }
+        }
+        return max = Math.max(max, count);
+    }
+}

longest-substring-without-repeating-characters/flynn.cpp

@@ -0,0 +1,42 @@
+/**
+ * 풀이
+ * - 주어진 문자열 `s`를 한 번 조회합니다
+ * - lookup이라는 해시맵 객체를 이용하여 현재 조회하고 있는
+ *   substring에 반복되는 문자가 있는지 검사합니다
+ * 
+ * Big O
+ * - N: 주어진 문자열 `s`의 길이
+ * 
+ * - Time complexity: O(N)
+ * - Space complexity: O(N)
+ */
+
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        if (s.size() == 0) return 0;
+
+        unordered_map<char, int> lookup;
+        lookup.insert({s[0], 0});
+
+        int res = 1;
+
+        int start = 0;
+        int end = 1;
+        
+        while (end < s.size()) {
+            if (lookup.find(s[end]) != lookup.end()
+                && lookup[s[end]] >= start) {
+                start = lookup[s[end]] + 1;
+            }
+
+            lookup[s[end]] = end;
+
+            res = max(res, end - start + 1);
+            
+            ++end;
+        }
+
+        return res;
+    }
+};

longest-substring-without-repeating-characters/haklee.py

@@ -0,0 +1,51 @@
+"""TC: O(n), SC: O(n)
+
+아이디어:
+투포인터로 문자열의 시작, 끝 인덱스를 관리한다. 그리고 문자열 안에 있는 문자를 set으로 관리한다.
+- 시작~끝 사이에 모든 문자가 서로 다르면 끝 인덱스를 하나 뒤로 옮긴다.
+- 새로운 문자열의 제일 끝에 있는 문자가 혹시 set 안에 있으면 시작 인덱스를 뒤로 옮기는 작업을
+  해당 문자랑 같은 문자가 나올 때까지 진행한다. 즉, 끝을 고정하고 앞을 계속 옮겨서 새로운 문자열에
+  있는 모든 문자들이 다른 문자가 되도록 만든다.
+    - e.g.) abcdefd -> abcdefd
+            ^     ^        ^ ^
+            s     e        s e
+- 위의 과정을 계속 반복하면서 문자열의 최대 길이 값을 갱신한다.
+
+SC:
+- 새로운 문자열의 시작과 끝 인덱스 값을 관리하는 데에 O(1).
+- 새로운 문자열 안에 들어있는 문자를 set으로 관리하는 데에 최악의 경우 n개의 문자가 모두 다를때 O(n).
+- 최대 문자열 길이를 관리하는 데에 O(1).
+- 종합하면 O(n).
+
+TC:
+- s, e는 모두 문자열의 인덱스를 나타내므로 s, e값을 아무리 많이 업데이트 해도 각가 문자열 길이보다
+  많이 업데이트 할 수는 없다. 즉, O(n).
+- set에서 특정 문자가 들어있는지 체크하고 set에 문자를 더하거나 제거하는 데에 O(1). 이 작업을 아무리
+  많이 해도 s, e를 업데이트 하는 회수 만큼 진행하므로 총 O(n).
+- 최대 문자열 길이를 업데이트 하는 데에 O(1). 이 또한 아무리 많이 진행해도 O(n).
+- 종합하면 O(n).
+"""
+
+
+class Solution:
+    def lengthOfLongestSubstring(self, string: str) -> int:
+        if len(string) < 1:
+            return 0
+        s = e = 0
+        letter_set = set([string[0]])
+        sol = 1
+        while True:
+            e += 1
+            if e == len(string):
+                break
+
+            if string[e] in letter_set:
+                while True:
+                    letter_set.discard(string[s])
+                    if string[s] == string[e]:
+                        break
+                    s += 1
+                s += 1
+            letter_set.add(string[e])
+            sol = max(len(letter_set), sol)
+        return sol

longest-substring-without-repeating-characters/jdalma.kt

@@ -0,0 +1,46 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import kotlin.math.max
+
+class `longest-substring-without-repeating-characters` {
+
+    fun lengthOfLongestSubstring(s: String): Int {
+        if (s.length <= 1) return s.length
+        return usingSet(s)
+    }
+
+    /**
+     * 1. 사용한 문자를 Set에 저장하여 확인하고, 중복된다면 해당 문자의 위치까지 모든 문자를 제거한다.
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingSet(s: String): Int {
+        var left = 0
+        val used = mutableSetOf<Char>()
+        var maxLength = 0
+
+        for (right in s.indices) {
+            if (!used.contains(s[right])) {
+                maxLength = max(right - left + 1, maxLength)
+                used.add(s[right])
+            } else {
+                while (used.contains(s[right])) {
+                    used.remove(s[left])
+                    left++
+                }
+                used.add(s[right])
+            }
+        }
+
+        return maxLength
+    }
+
+    @Test
+    fun `입력받은 문자열의 반복되는 문자가 없는 가장 긴 부분 문자열의 길이를 반환한다`() {
+        lengthOfLongestSubstring("ababc") shouldBe 3
+        lengthOfLongestSubstring("bbbbb") shouldBe 1
+        lengthOfLongestSubstring("abcabcbb") shouldBe 3
+        lengthOfLongestSubstring("pwwkew") shouldBe 3
+    }
+}

longest-substring-without-repeating-characters/kayden.py

@@ -0,0 +1,20 @@
+class Solution:
+    # 시간복잡도: O(N)
+    # 공간복잡도: O(N)
+    # set에서 제외하는 로직을 없애기 위해, map을 사용해서 idx값을 저장후, start와 비교해서 start보다 작은 idx를 가진 경우에는 중복이 아니라고 판단했습니다.
+    def lengthOfLongestSubstring(self, s: str) -> int:
+
+        last_idx = {}
+        answer = 0
+        start = 0
+
+        for idx, ch in enumerate(s):
+            # 중복 조회시 idx값과 start 값 비교를 통해, 삭제하는 로직을 없이 중복을 확인했습니다.
+            if ch in last_idx and last_idx[ch] >= start:
+                start = last_idx[ch] + 1
+                last_idx[ch] = idx
+            else:
+                answer = max(answer, idx - start + 1)
+                last_idx[ch] = idx
+
+        return answer

longest-substring-without-repeating-characters/yeonguchoe.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+
+        int current_max = 0;
+        int pivot = 0;
+        int checker = 0;
+
+        int current_length = 0;
+        while (pivot < s.size()) {
+            set<char> included;
+            included.insert(s[pivot]);
+            checker = pivot + 1;
+            while (checker < s.size() and
+                   included.find(s[checker]) == included.end()) {
+                included.insert(s[checker]);
+                checker += 1;
+            }
+            current_length = checker - pivot;
+            current_max = max(current_max, current_length);
+            pivot += 1;
+        }
+        return current_max;
+    }
+    // 시간 복잡도: O(n)
+    // 공간 복잡도: O(n)
+};