Solution: 3. Longest Substring Without Repeating Characters

Author: RootProgrammer

CodingChallenges/LeetCode/longest-substring-without-repeating-characters/input.txt

@@ -1 +1,12 @@
-# Start here
+abcabcbb
+bbbbb
+pwwkew
+abcdef
+a
+aa
+abababab
+emptystringtest
+z
+!@#$%^&*()_+
+1234567890
+abba

CodingChallenges/LeetCode/longest-substring-without-repeating-characters/insight.md

@@ -26,4 +26,58 @@ Given a string `s`, find the length of the longest **substring** (A substring is
 ### Constraints
 
 - `0 <= s.length <= 5 * 104`
-- `s` consists of English letters, digits, symbols and spaces.
+- `s` consists of English letters, digits, symbols, and spaces.
+
+## Problem Breakdown
+
+This problem is a classic example that utilizes the Sliding Window technique, which is particularly effective for challenges involving contiguous sequences of elements such as substrings or subarrays.
+
+### Understanding the Problem
+
+The goal is to identify the longest substring of `s` that contains no repeating characters. Key considerations include handling strings of varying lengths and compositions, from completely unique strings to those with repetitive characters.
+
+### Edge Cases
+
+- **Empty string**: Returns a length of 0.
+- **Uniform character string**: Such as "aaaa", should return 1 because there is only one unique character.
+- **All unique characters**: Returns the length of the string itself.
+
+## Approach: Sliding Window
+
+This technique involves two pointers to define a moving window of characters that expands and contracts based on the uniqueness of characters within it.
+
+### Solution Explanation
+
+- **Initialization**: Two pointers, `left` and `right`, start at the beginning of the string, with a set to track characters within the current window.
+- **Expansion**: The `right` pointer moves to the right, adding new characters to the set.
+- **Contraction**: When a duplicate character is found, the `left` pointer moves right until the duplicate is removed from the set, thereby making the substring unique again.
+- **Tracking Maximum**: The maximum length of the substring without repeating characters is updated continuously as the window adjusts.
+
+### Example Walkthrough
+
+- **Input**: "abcabcbb"
+  - Expands to "abc", then encounters a duplicate 'a'.
+  - Contracts by moving the left pointer to just past the first 'a'.
+  - Continues until the end, updating the maximum length found.
+
+## Applied Data Structure and Algorithm
+
+- **Data Structure**: Uses a set to efficiently check for duplicates and to quickly clear items when necessary.
+- **Algorithm**: Implements the Sliding Window technique with dynamic adjustment of window boundaries based on the condition of uniqueness.
+
+## Complexity Analysis
+
+- **Time Complexity**: O(n), where `n` is the length of the string. Each character is processed at most twice (once added and once removed).
+- **Space Complexity**: O(min(m, n)), where `m` is the size of the character set, and `n` is the length of the string.
+
+## What We've Learned
+
+- The sliding window technique is incredibly effective for problems involving substrings or subarrays where the condition of the window changes dynamically based on the sequence content.
+- Using a set facilitates O(1) time complexity for adding and removing characters, making the solution efficient even for large strings.
+
+## Key Notes
+
+- The solution gracefully handles all types of strings by dynamically adjusting the window size.
+- It’s essential to consider how the data structure used (in this case, a set) can significantly impact the efficiency of the solution.
+
+---

CodingChallenges/LeetCode/longest-substring-without-repeating-characters/output.txt

@@ -1 +1,12 @@
-# Start here
+3
+1
+3
+6
+1
+1
+2
+7
+1
+12
+10
+2

CodingChallenges/LeetCode/longest-substring-without-repeating-characters/solution.py

@@ -1,3 +1,44 @@
 class Solution:
     def lengthOfLongestSubstring(self, s: str) -> int:
-        pass
+        char_set = set()
+        left = 0
+        max_length = 0
+
+        # Check for empty string
+        if not s:
+            return 0
+
+        for right in range(len(s)):
+            # Continue to slide the window if duplicate is found
+            while s[right] in char_set:
+                char_set.remove(s[left])
+                left += 1
+            char_set.add(s[right])
+            # Update max_length after ensuring s[right] is added to the set
+            max_length = max(max_length, right - left + 1)
+
+        return max_length
+
+# For testing
+class Test:
+    def test(self):
+        solution = Solution()
+        with open('input.txt', 'r') as input_file, open('output.txt', 'r') as output_file:
+            passed = True
+            for input_line, expected_output_line in zip(input_file, output_file):
+                input_str = input_line.strip()
+                expected_output = int(expected_output_line.strip())  # Expected output is an integer
+                actual_output = solution.lengthOfLongestSubstring(input_str)
+                if actual_output == expected_output:
+                    print(f"Passed: {input_str} -> {actual_output}")
+                else:
+                    print(f"Failed: {input_str} -> {actual_output} (Expected: {expected_output})")
+                    passed = False
+            if passed:
+                print("All test cases passed!")
+            else:
+                print("Some test cases failed.")
+
+if __name__ == "__main__":
+    test_code = Test()
+    test_code.test()