Word Reverser

easyFREEText ProcessingNLP 1: Foundations

Given a sentence, reverse each word individually while keeping the word order the same.

Example:

Input: "hello world"
Reversed words: "olleh dlrow"

Words are separated by single spaces. Preserve the original casing of each character.

Example

Input

hello world

Output

olleh dlrow

Reasoning

Input: text is one sentence, here hello world: two words, each a sequence of characters, with a single space between them.
One word: a word $w = c_1 c_2 \dots c_n$ becomes $c_n c_{n-1} \dots c_1$ , the same letters read from last to first. For hello ( $n = 5$ ): $c_5 =$ o, $c_4 =$ l, $c_3 =$ l, $c_2 =$ e, $c_1 =$ h, giving olleh.
Second word: world read backwards is d, l, r, o, w, giving dlrow.
Output: the reversed words stay in their original positions with one space between them, so the result is olleh dlrow. Each word keeps its length, so the output has exactly as many characters as the input.
Notice: only the letters inside each word move, never the words themselves. Reversing the whole sentence would give dlrow olleh instead. Casing travels with each character, so NLP becomes PLN, and a one-letter word like a is unchanged.

Constraints

Input: A single line of text
Words are separated by single spaces
Output: Each word reversed, space-separated
Preserve original character casing

More from NLP 1: Foundations

Embedding Lookupeasy Cosine Similarity Calculatoreasy Binary Vectorizereasy Document Term Matrixeasy Character Frequency Countereasy

Concept primer

Background Knowledge

The "Word Reverser" problem falls under the category of text processing, a fundamental aspect of Natural Language Processing (NLP). Text processing involves manipulating and analyzing text data, which can include tasks such as tokenization, stemming, and text normalization. In this problem, we're dealing with a simple yet essential operation: reversing the characters within each word of a given sentence. Understanding how to work with strings and manipulate their contents is crucial for solving this problem.

To approach this problem, it's essential to have a basic understanding of string manipulation techniques. This includes knowing how to split strings into substrings (or tokens), access individual characters, and concatenate strings. Additionally, being familiar with looping constructs and conditional statements will help in iterating over the characters within each word and handling any necessary logic for preserving the original casing.

The problem also touches on the concept of in-place modification versus creating new strings. Depending on the chosen approach, you might need to decide whether to modify the original string or create a new one with the reversed words. This decision can impact the efficiency and readability of your solution.

Algorithm/Approach

The general approach to solving this problem involves a combination of string splitting, iteration, and string reversal. You can think of it as a three-step process: (1) split the input sentence into individual words, (2) reverse each word while preserving its casing, and (3) combine the reversed words back into a sentence. This pattern is a common one in text processing tasks, where you often need to break down text into smaller units, perform some operation on each unit, and then reassemble the results.

Step-by-Step Strategy

To implement the solution, follow these steps:

Split the input sentence into a list of words using a space as the delimiter.
Iterate over each word in the list.
For each word, reverse its characters while preserving the original casing.
Combine the reversed words back into a sentence, ensuring they are separated by single spaces.

Common Pitfalls

When implementing the solution, watch out for the following:

Forgetting to handle the casing of characters correctly, which could result in losing the original casing of the words.
Not checking for edge cases, such as an empty input sentence or a sentence with multiple consecutive spaces.
Using inefficient string manipulation methods, which could impact performance for large input sentences.

Time & Space Complexity

The expected time complexity for this problem is $O(n \cdot m)$ , where $n$ is the number of words in the sentence and $m$ is the maximum length of a word. This is because you need to iterate over each character in each word to reverse it. The space complexity is also $O(n \cdot m)$ , as you need to store the reversed words before combining them back into a sentence. However, the exact complexity can vary depending on the specific implementation and the programming language used.

solution.py

Python 3.13

Test results