LeetCode 434: Number of Segments in a String Solution in Python – A Step-by-Step Guide

What Is LeetCode 434: Number of Segments in a String?

LeetCode 434: Number of Segments in a String is all about counting "segments"—sequences of non-space characters separated by one or more spaces—in a given string. You get a single input: a string s. Your task? Return the number of segments. Empty segments (like consecutive spaces) don’t count, and if the string is empty or all spaces, the answer is 0. It’s like counting the words in a sentence, but with a twist: we’re only interested in non-empty chunks.

Problem Statement

• Input: s (string).
• Output: Integer—the number of segments.
• Rules:
• A segment is a contiguous sequence of non-space characters.
• Segments are separated by one or more spaces.
• Empty strings or all-space strings have 0 segments.

Constraints

• 0 <= s.length <= 300.
• s contains lowercase/uppercase letters, digits, or special characters (plus spaces).
• Only spaces (' ') separate segments—no tabs or funky whitespace.

Examples to Kick Things Off

• Input: s = "Hello, my name is John"
• Output: 5 (Segments: "Hello", "my", "name", "is", "John").
• Input: s = "Hello"
• Output: 1 (One segment: "Hello").
• Input: s = " "
• Output: 0 (All spaces, no segments).
• Input: s = ""
• Output: 0 (Empty string, no segments).

Understanding the Problem: Counting Islands of Text

To solve LeetCode 434: Number of Segments in a String in Python, we need to identify and count non-empty sequences of characters between spaces. A naive approach might be to scan every character and tally transitions—but there’s a smarter way! We’ll explore:

• Best Solution (Split-Based): O(n) time, O(n) space—uses Python’s built-in tools for speed.
• Alternative Solution (Character Iteration): O(n) time, O(1) space—manual but memory-light.

Let’s start with the split-based solution—it’s the star of this string-counting show.

Best Solution: Split-Based Approach

Why This Is the Best Solution

The split-based approach is the champ because it’s concise, leverages Python’s optimized split() method, and handles the problem in one clean swoop—O(n) time and O(n) space. It splits the string on spaces, filters out empty segments, and counts what’s left. It’s like tossing the string into a blender, letting Python chop it up, and counting the solid pieces—fast and effortless!

How It Works

Here’s the plan:

• Step 1: Use s.split() to break the string into a list of substrings, splitting on any number of spaces.
• Step 2: Count the non-empty substrings in the list—those are your segments.
• Step 3: Return the count (or 0 if the list is empty).
• Why It Works:
• split() with no arguments treats consecutive spaces as one delimiter, skipping empty segments.
• It’s built into Python, so it’s optimized and reliable.

Step-by-Step Example

Example 1: s = "Hello, my name is John"

• Split: s.split() → ["Hello,", "my", "name", "is", "John"].
• Count: 5 non-empty segments.
• Result: 5.

Example 2: s = " Hello World "

• Split: s.split() → ["Hello", "World"] (leading/trailing/consecutive spaces ignored).
• Count: 2 segments.
• Result: 2.

Example 3: s = " "

• Split: s.split() → [] (all spaces, no segments).
• Count: 0.
• Result: 0.

Code with Detailed Line-by-Line Explanation

Here’s the Python code, broken down for clarity:

Copy codeclass Solution:
    def countSegments(self, s: str) -> int:
        # Split on spaces and count non-empty segments
        return len(s.split())

• Line 3: s.split():
• Splits s on whitespace (spaces), collapsing multiple spaces into one delimiter.
• Returns a list of substrings (e.g., "Hello World" → ["Hello", "World"]).
• Empty or all-space strings return an empty list [].
• Line 3 (cont.): len():
• Counts the number of elements in the list—our segment count.
• For [], returns 0, handling edge cases perfectly.
• Time Complexity: O(n)—splitting scans the string once.
• Space Complexity: O(n)—stores the list of segments.

That’s it! Three lines, one powerful move. It’s like Python does the heavy lifting while you sip coffee.

A Slightly More Explicit Version

If you want to see the filtering in action, here’s an expanded version:

Copy codeclass Solution:
    def countSegments(self, s: str) -> int:
        # Split and filter out empty strings explicitly
        segments = [seg for seg in s.split() if seg]
        return len(segments)

• Line 3: List comprehension ensures only non-empty segments count (though split() already handles this).
• Same complexity, just more visible steps.

Both versions are slick, but the one-liner is the ultimate flex.

Alternative Solution: Character-by-Character Iteration

Why an Alternative Approach?

The character-by-character iteration method is a hands-on alternative—O(n) time, O(1) space—that counts segments by scanning the string directly. It’s less reliant on built-in methods, making it a great learning tool or a fit for languages without a smart split(). It’s like walking the string beach, counting islands as you spot them, without needing a fancy map.

How It Works

• Step 1: Initialize a segment counter.
• Step 2: Scan each character:
• When you hit a non-space after a space (or start), it’s a new segment.
• Track the previous character to detect transitions.
• Step 3: Return the total count.
• Why It Works:
• It catches every segment start by watching for non-space characters following spaces.

Step-by-Step Example

Example 1: s = "Hello, my name is John"

• Scan:
• "H" (after nothing, start segment) → count = 1.
• " " (space, end of "Hello").
• "m" (after space, new segment) → count = 2.
• " " → "n" → count = 3.
• " " → "i" → count = 4.
• " " → "J" → count = 5.
• Result: 5.

Example 2: s = " Hello World "

• Scan:
• " " (spaces, no count).
• "H" (after space, start) → count = 1.
• " " (spaces).
• "W" (after space) → count = 2.
• Trailing spaces ignored.
• Result: 2.

Code for Iteration Approach

Copy codeclass Solution:
    def countSegments(self, s: str) -> int:
        if not s:
            return 0

        count = 0
        for i in range(len(s)):
            # New segment: non-space char after a space or at start
            if s[i] != ' ' and (i == 0 or s[i-1] == ' '):
                count += 1
        return count

• Line 3-4: Early exit for empty string—0 segments.
• Line 6: count tracks segments.
• Line 7-9: Loop through characters:
• Check if current char is non-space (s[i] != ' ').
• Check if it’s the start (i == 0) or follows a space (s[i-1] == ' ').
• If true, increment count.
• Line 10: Return total.
• Time Complexity: O(n)—one pass through the string.
• Space Complexity: O(1)—just a counter.

It’s a bit more manual, but it’s lean and mean!

Comparing the Two Solutions

• Split-Based (Best):
• Pros: O(n), concise, Python-optimized, handles edge cases effortlessly.
• Cons: O(n) space for the list.
• Character Iteration (Alternative):
• Pros: O(n), O(1) space, explicit control.
• Cons: More code, slightly slower due to manual checks.

Split wins for simplicity and speed.

Additional Examples and Edge Cases

• Input: s = "a b".
• Split: ["a", "b"] → 2.
• Iteration: "a" (1), "b" (2) → 2.
• Input: s = " ".
• Split: [] → 0.
• Iteration: All spaces → 0.
• Input: s = "a":
• Split: ["a"] → 1.
• Iteration: "a" → 1.

Both solutions nail these.

Complexity Breakdown

• Split-Based: Time O(n), Space O(n).
• Iteration: Time O(n), Space O(1).

Split’s elegance comes at a small space cost.

Key Takeaways

• Split: Python’s string magic—fast and clean.
• Iteration: Hands-on, memory-light control.
• Strings: Simple problems, big lessons—see [Python Basics](/python/basics).

Final Thoughts: Count Those Segments

LeetCode 434: Number of Segments in a String in Python is a delightful string-handling warm-up. The split-based solution is your quick win, while character iteration builds your intuition. Want more string fun? Check out LeetCode 344: Reverse String or LeetCode 557: Reverse Words in a String III. Ready to count some segments? Hit up Solve LeetCode 434 on LeetCode and master this challenge today—your string skills are calling!