What is the time complexity of Length of Last Word?

The optimal solution has a time complexity of O(n).

What data structures are used to solve Length of Last Word?

This problem uses String. Understanding these concepts is essential for solving this Easy problem efficiently.

What are the key insights for solving Length of Last Word?

**Strategic `str.strip()` usage:** Pre-processing the string with `s.strip()` is paramount. It intelligently removes all leading and trailing whitespace, ensuring that `split()` operates on a clean string and doesn't produce spurious empty strings at the list boundaries, which could otherwise throw off the identification of the 'last' word. **`str.split()`'s default magic:** Leveraging `s.split()` without specifying a delimiter is a powerful Pythonic idiom. It's designed to split by *any* amount of whitespace and automatically handles multiple spaces between words by treating them as a single separator, while also discarding any empty strings that would otherwise result. This directly maps to the 'maximal substring' word definition.

Which companies ask LeetCode 58. Length of Last Word in interviews?

This problem is frequently asked at Adobe, Amazon, Apple, Bloomberg, Meta and 5 more companies.

JavaScript is required for the full interactive experience. However, all content is accessible without JavaScript.

Length of Last Word - LeetCode 58 Solution

Length of Last Word - Complete Solution Guide

Length of Last Word is LeetCode problem 58, a Easy level challenge. This complete guide provides step-by-step explanations, multiple solution approaches, and optimized code in python3, java, cpp, c.

Problem Statement

Given a string s consisting of words and spaces, return the length of the last word in the string. A word is a maximal substring consisting of non-space characters only. Example 1: Input: s = "Hello World" Output: 5 Explanation: The last word is "World" with length 5. Example 2: Input: s = " fly me to the moon " Output: 4 Explanation: The last word is "moon" with length 4. Example 3: Input: s = "luffy is still joyboy" Output: 6 Explanation: The last word is "joyboy" with length 6. Constraints: 1

Detailed Explanation

This problem asks us to pinpoint the length of the *final* word in a given string `s`. Sounds simple enough, right? But the devil, as always, is in the details – specifically, how we define a 'word' and what constitutes 'last'. A word here isn't just any sequence of non-space characters; it's a *maximal* substring of non-space characters. This means 'Hello World' has 'Hello' and 'World' as words, not 'Hel' and 'lo'. The real challenge and the source of potential pitfalls lie in the diverse ways spaces can appear. Consider strings like `s = " fly me to the moon "`. We have leading spaces, trailing spaces, and multiple spaces between words. All these need to be handled gracefully so that 'moon' is correctly identified as the last word, and its length (4) is returned. The problem essentially boils down to intelligently parsing the string, dismissing superfluous whitespace, and isolating that very last meaningful sequence of characters.

Solution Approach

The provided Pythonic solution beautifully leverages built-in string methods to tackle this problem with remarkable conciseness and efficiency. Its elegance stems from a three-step dance. First, `s.strip()` is called. This essential step lops off any leading or trailing whitespace characters from the original string. This isn't just a nicety; it ensures that when we later split the string, we don't end up with empty strings at the beginning or end of our word list, which could confuse the 'last word' identification. For example, `" hello world "` becomes `"hello world"`. Next, `s.split()` takes center stage. When called without any arguments, Python's `split()` method is incredibly smart: it automatically splits the string by *any* sequence of whitespace characters (spaces, tabs, newlines) and, crucially, discards any resulting empty strings. This perfectly aligns with our 'maximal substring' definition of a word and cleanly separates words even when there are multiple spaces between them, like `"fly me to the moon"` turning into `['fly', 'me', 'to', 'moon']`. Finally, `words[-1]` directly accesses the very last element of the list of words. Python's negative indexing makes this trivial. Applying `len()` to this last word then gives us its character count, fulfilling the problem's requirement.

Step-by-Step Algorithm

Step 1: Remove leading and trailing spaces from the input string (optional but recommended for clarity).
Step 2: Locate the last word. This can be done by iterating from the end of the string (C++, efficient), using string splitting (Python), or finding the last space character's index (Java).
Step 3: Calculate the length of the last word by counting characters from the end of the string until a space is found (or end of string is reached).
Step 4: Return the calculated length.

Key Insights

**Strategic `str.strip()` usage:** Pre-processing the string with `s.strip()` is paramount. It intelligently removes all leading and trailing whitespace, ensuring that `split()` operates on a clean string and doesn't produce spurious empty strings at the list boundaries, which could otherwise throw off the identification of the 'last' word.
**`str.split()`'s default magic:** Leveraging `s.split()` without specifying a delimiter is a powerful Pythonic idiom. It's designed to split by *any* amount of whitespace and automatically handles multiple spaces between words by treating them as a single separator, while also discarding any empty strings that would otherwise result. This directly maps to the 'maximal substring' word definition.
**Python's Negative Indexing for 'Last':** Directly accessing the last element of the word list using `words[-1]` is an idiomatic and highly readable way to pinpoint the 'last word' in Python. It's clean, concise, and avoids needing to calculate the list's length and then subtract one for the index.

Complexity Analysis

Time Complexity: O(n)

Space Complexity: O(n)

Topics

This problem involves: String.

Companies

Asked at: Adobe, Amazon, Apple, Bloomberg, Meta, Microsoft, Qualcomm, Uber, Yahoo, tcs.

Length of Last Word | LeetCode 58

Easy

String

Time: O(n)Space: O(n)

Solution Code

Available in:

class Solution {
    public int lengthOfLastWord(String s) {
        s = s.trim();
        int lastIndex = s.lastIndexOf(" ");
        if (lastIndex == -1) {
            return s.length();
        }
        return s.length() - lastIndex - 1;
    }
}

View Full Solution on GitHubGitHub Solution View on LeetCodeLeetCode

Problem Info

Description

Problem 58: Length of Last Word - Detailed explanation and solution approaches.

Topics

String

Companies

AdobeAmazonAppleBloombergMetaMicrosoftQualcommUber

Stats

Difficulty:Easy

Languages:4

Companies:10

Problem #:58

Problem Explanation

💡

Think Before You Code

🤔 Ask Yourself

→What is the input? What output do I need?
→Can I solve a smaller version of this problem first?
→What patterns have I seen in similar problems?

✏️ Try This First

Before looking at the solution, try to solve it on paper with a simple example!

🚀 Try on LeetCode

Solution Approach

📋

Step-by-Step Solution

4 steps

1
Step 1: Remove leading and trailing spaces from the input string (optional but recommended for clarity).
2
Step 2: Locate the last word. This can be done by iterating from the end of the string (C++, efficient), using string splitting (Python), or finding the last space character's index (Java).
3
Step 3: Calculate the length of the last word by counting characters from the end of the string until a space is found (or end of string is reached).
4
Step 4: Return the calculated length.

💡

Pro Tip for Students

Try tracing through each step with a small example on paper before coding. Understanding "why" each step happens is more important than memorizing the code!

⚡

Complexity Analysis

⏱️

Time Complexity

O(n)

👍 Linear - Good! Visits each element once.

💾

Space Complexity

O(n)

📦 Linear space - Memory grows with input size.

📝

Why?

The string traversal (iterative or using `split()`) is the dominant operation. In the Python solution, the split operation might create a list of words in space proportional to the number of words, but this remains linear in string length. The other solutions use constant extra space for storing the length, index, and iteration counters.

📖New to Big O? Click to learn more

Big O Notation - Quick Guide

O(1)Best - Instant

O(log n)Excellent - Binary Search

O(n)Good - One loop

O(n log n)OK - Sorting

O(n²)Slow - Nested loops

O(2ⁿ)Very Slow - Recursion

Alternative Approaches

Reverse Iteration and Counting

Iterate through the string from the end, counting characters until a space is encountered. This avoids the need for string splitting or finding the last space index.

Time: O(n)Space: O(1)

Trade-offs: This approach is generally more efficient than using `split()` if dealing with very large strings and avoids creating a temporary list of words.

✨

Key Insights

1**Strategic `str.strip()` usage:** Pre-processing the string with `s.strip()` is paramount. It intelligently removes all leading and trailing whitespace, ensuring that `split()` operates on a clean string and doesn't produce spurious empty strings at the list boundaries, which could otherwise throw off the identification of the 'last' word.
2**`str.split()`'s default magic:** Leveraging `s.split()` without specifying a delimiter is a powerful Pythonic idiom. It's designed to split by *any* amount of whitespace and automatically handles multiple spaces between words by treating them as a single separator, while also discarding any empty strings that would otherwise result. This directly maps to the 'maximal substring' word definition.
3**Python's Negative Indexing for 'Last':** Directly accessing the last element of the word list using `words[-1]` is an idiomatic and highly readable way to pinpoint the 'last word' in Python. It's clean, concise, and avoids needing to calculate the list's length and then subtract one for the index.

📚

Key Terms Explained

For Students

String

A sequence of characters. Like a word or sentence in programming!

Edge Cases

Edge case 1: String with only spaces – The solutions correctly handle this by returning 0 (or handling the empty string/list after trimming).
Edge case 2: String with a single word – The solutions correctly handle this and return the length of that single word.
Edge case 3: Multiple trailing spaces - The leading `strip()` or equivalent handling in the solutions effectively takes care of extra spacing.

⚠️

Common Mistakes to Avoid

✗Common mistake 1: Forgetting to handle leading/trailing spaces, resulting in incorrect length calculations. Using `strip()` (Python) or `trim()` (Java) is essential.

✗Common mistake 2: Incorrectly handling edge cases like a string containing only spaces or a single word. Thorough testing of edge cases is crucial.

✗Common mistake 3: Off-by-one errors in calculating the length of the last word. Carefully considering the loop boundaries and index calculations is important.

✅

Learning Tip

Every mistake is a learning opportunity! When you make an error, understand why it happened before moving on.

🌍

Where is This Used in Real Life?

💼Real-world scenario 1: Text processing and natural language processing tasks, such as extracting keywords or analyzing sentence structure. Finding the last word can be a preprocessing step.

🏦Real-world scenario 2: Log file analysis – extracting the last component of a log message (e.g., a filename or error code) that is space-delimited.

💡Understanding real-world applications helps you see the "why" behind algorithms. It's not just about passing interviews—these concepts power the apps and websites you use every day!

Author's Notes

💡 Key Insight

String problems often involve sliding windows or two pointers. Consider if the character set is limited (lowercase letters = only 26 possibilities).

🎯 Interview Tip

Use this problem to demonstrate clean code practices. Variable naming and code organization matter.

⚠️ Watch Out

Mutating strings directly in languages where strings are immutable. Use StringBuilder or arrays.

Written by Saswata Mondal

Software Engineer • Algorithms Enthusiast • Interview Coach

👨‍💻

About the Author

👨‍💻

Saswata MondalAuthor400+ LC Problems

B.Tech CSE, IEM Kolkata | LeetCode Rating: 1672 (Top 15%)

Certified: IBM Java Developer, NPTEL Programming in Java

Last updated: July 29, 2024LeetCode Profile GitHub

This solution has been crafted based on my experience solving 400+ LeetCode problems. Each explanation is designed to help you understand the underlying concepts, not just memorize the code.

Community Tips & Insights

Try solving this without using extra space first. It's a great exercise for understanding the underlying pattern.

@CodeNinjaJul 13

In a real interview, always clarify constraints first. Ask about input size and value ranges.

@TechLeadJul 6

❓

Frequently Asked Questions

How do I handle string manipulation efficiently?

In languages with immutable strings (Java, Python, C#), use StringBuilder/list to avoid O(n) concatenation cost. Consider using character arrays for in-place modifications. For pattern matching, consider KMP or Rabin-Karp for O(n+m) complexity.

How should I approach easy-level algorithm problems?

Easy problems build foundational skills. Focus on: 1) Understanding the problem completely before coding, 2) Writing clean, readable code, 3) Handling all edge cases (empty input, single element, etc.), 4) Analyzing time and space complexity. Don't skip complexity analysis even for simple solutions.

How should I practice algorithm problems effectively?

Focus on understanding patterns rather than memorizing solutions. After solving a problem, review optimal solutions and understand the intuition. Group similar problems to recognize patterns. Practice explaining your approach out loud. Review problems after a few days to test retention.

What is the optimal approach for "Length of Last Word"?

For this easy-level String problem, the key is to identify the core pattern. Analyze the input constraints to determine acceptable time complexity. Consider whether standard techniques can optimize the solution. Always handle edge cases and validate your approach with examples before coding.

🤖 Need help with this problem?