Reverse Every Word in a String

Contents

ProblemExamplesVisualizationSolutionAlgorithmCodeTimeSpace

Problem Statement❯

Given a string containing one or more words separated by spaces, your task is to reverse each word individually, while keeping the order of words the same.

Each word is defined as a sequence of characters separated by spaces. Spaces should be preserved between words, but the characters of each word should appear in reverse order.

This operation should not affect extra spaces or punctuation. The final result should be a single string with all words reversed.

Examples❯

Input String Output String Description
"hello world" "olleh dlrow" Each word is reversed individually
"data structures" "atad serutcurts" Two words reversed, order remains
" a b c " " a b c " Single-letter words are the same; spaces preserved
" hello world " " olleh dlrow " Multiple spaces between and around words are preserved
"example" "elpmaxe" Single word reversed
" " " " Only spaces, no words to reverse
"" "" Empty string returns empty string

Visualization Player

Solution❯

To solve this problem, the goal is to reverse the characters of each individual word while maintaining the original word order and spacing.

Let’s break it down:

1. Words are separated by spaces: So the first step is to split the input string into a list of words. For example, splitting "hello world" by spaces gives us ["hello", "world"].

2. Reverse each word: Now, for each word in the list, we reverse its characters. "hello" becomes "olleh", and "world" becomes "dlrow".

3. Maintain spacing: When joining the words back, we use exactly one space between them. However, it’s important to handle leading, trailing, or multiple spaces correctly. If the original string had extra spaces, the output should reflect that. In programming, some built-in functions like split() remove extra spaces, so we might have to handle spacing manually in those cases.

4. What happens in edge cases?

  • If the input is an empty string (""), there’s nothing to reverse, so the output should also be an empty string.
  • If the input contains only spaces (like " "), then the result should still be the same number of spaces—there are no words to reverse.
  • If the input has one word, then we simply reverse that word and return.
  • If the input contains punctuation or symbols, we treat them as part of the word and reverse them along with the word. For example, "hello!" becomes "!olleh".

This solution is efficient and easy to understand. It makes use of string operations like splitting, reversing, and joining—all of which are beginner-friendly and commonly available in most programming languages.

Final note: Always consider edge cases like empty strings, multiple spaces, or single-letter words. The trick is to focus only on reversing characters of each word and not disturbing the spacing unless required by the problem.

Algorithm Steps❯

  1. Split the input string using space as delimiter into a list of words.
  2. Iterate through each word in the list.
  3. For each word, reverse its characters using a loop or inbuilt reverse method.
  4. Join all the reversed words using a single space.
  5. Return the resulting string.

Code

Java
Python
JavaScript
C
C++
C#
Kotlin
Swift
Go
Php
public class ReverseWords {
  public static String reverseEachWord(String s) {
    String[] words = s.split(" ", -1); // include trailing spaces
    StringBuilder result = new StringBuilder();

    for (int i = 0; i < words.length; i++) {
      StringBuilder word = new StringBuilder(words[i]);
      result.append(word.reverse());
      if (i != words.length - 1) result.append(" ");
    }
    return result.toString();
  }

  public static void main(String[] args) {
    String input = "Hello World";
    System.out.println("Reversed: " + reverseEachWord(input));
  }
}

Time Complexity

CaseTime ComplexityExplanation
Best CaseO(n)We scan each character in the string once during splitting, reversing, and joining.
Average CaseO(n)Each word is reversed individually, and all characters are processed linearly.
Worst CaseO(n)Even if the string has long words or many spaces, we still traverse each character only once.

Space Complexity

O(n)

Explanation: A new string is built to store the reversed output, proportional to the input size.