# Leetcode – Reverse Words in a String III Solution in Python

## Introduction

String manipulation is a common theme in coding interviews and programming in general. The Reverse Words in a String III problem on Leetcode is an intriguing example that involves the reversal of characters within words. Through this comprehensive article, we will delve into the Reverse Words in a String III problem, understand its intricacies, and investigate various methods to address this challenge in Python.

The problem is described as follows:

Given a string, you need to reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.

For Example:

Input: "Let's take LeetCode contest"
Output: "s'teL ekat edoCteeL tsetnoc"

## Approach 1: Utilizing Python’s Built-in Functions

One of Python’s strengths is its expressive syntax and powerful built-in functions. We can use these features to craft a concise solution. The idea here is to split the input string into words, reverse each word, and then join them back together with spaces.

Here’s the Python code for this approach:

def reverseWords(s):
# Split the string into words
words = s.split()

# Reverse each word and join them back together
return ' '.join(word[::-1] for word in words)

This approach has a time complexity of O(n), where n is the length of the string.

## Approach 2: Two-Pointer Technique

While the first approach is concise, it’s worth considering alternative methods. One such method is the two-pointer technique. We can use two pointers to mark the start and end of each word and reverse the characters within these boundaries in-place.

Here’s the Python code for this approach:

def reverseWords(s):
# Convert the string to a list of characters
chars = list(s)

# Initialize pointers
start = 0
end = 0

# Iterate through the characters
while end < len(chars):
# Move the end pointer to the end of the current word
while end < len(chars) and chars[end] != ' ':
end += 1

# Reverse the characters in the current word
chars[start:end] = chars[start:end][::-1]

# Move the start pointer to the start of the next word
start = end + 1
end = start

# Join the characters back into a string
return ''.join(chars)

This approach also has a time complexity of O(n), but involves manual handling of pointers, which provides a deeper understanding of the problem.

## Approach 3: Utilizing Python’s map Function

Python’s map function is a powerful tool that can be employed to apply a function to every item in an iterable. We can use the map function to reverse each word in the list of words obtained from splitting the input string.

Here’s the Python code for this approach:

def reverseWords(s):
# Split the string into words
words = s.split()

# Reverse each word using map and join them back together
return ' '.join(map(lambda word: word[::-1], words))

This approach is similar to the first one but demonstrates the application of the map function.

## Testing the Solutions

Let’s test the solutions with some examples:

# Test Case 1
print(reverseWords("Let's take LeetCode contest"))
# Output should be "s'teL ekat edoCteeL tsetnoc"

# Test Case 2
print(reverseWords("Hello World"))
# Output should be "olleH dlroW"

# Test Case 3
print(reverseWords("Python is fun"))
# Output should be "nohtyP si nuf"

## Conclusion

In this detailed article, we explored the Reverse Words in a String III problem on Leetcode. We investigated three distinct approaches: utilizing Python’s built-in functions, applying the two-pointer technique, and employing Python’s map function. This problem is an excellent illustration of string manipulation and the flexibility that Python offers through its built-in functions.