How Do You Reverse Words and Characters?

Three variants come up, and they have different answers. Reverse the characters of a string — use a StringBuilder and its reverse method. Reverse the words of a sentence, keeping the words themselves intact — split on whitespace, then rebuild in the opposite order. And reverse each word in place while keeping the word order — split, reverse each piece, and join again.

For the first variant, a StringBuilder is the right answer and a loop over a char array is the wrong one. The StringBuilder approach is O(n) time and O(n) space, and it is what the interviewer is looking for. The manual loop over a char array is also O(n) but it is more code and it is easy to get the boundaries wrong.

For the word variants, the trap is split behaviour. The default split on a space produces empty strings for runs of spaces, and the trailing empty strings are removed, so a sentence with a trailing space or a double space does not come back the way you expect. Passing a limit of -1 keeps every empty piece, and trimming the input first removes the leading and trailing whitespace.

The other trap is Unicode. The String methods work in UTF-16 code units, so a supplementary character such as an emoji occupies two chars and reversing the code units reverses the pair into something that is not a character at all. For text that can contain such characters, work with code points rather than chars.

One more variant worth knowing: reversing the words of a sentence in place, which needs a different technique entirely — find the start and end of each word, reverse that range, and move on. That is the question that distinguishes candidates who have only memorised the split-and-join answer.

Reversing the word order means splitting the text into words and reassembling them in reverse. The details that matter are trimming first, so leading and trailing whitespace does not produce empty pieces, and using a limit of -1 only if you genuinely want the empties preserved.

The palindrome check is the same idea plus a normalisation step. Strip everything that is not a letter or a digit, fold the case, and compare the result with its own reverse. That handles the classic phrase with punctuation and mixed case.

public class Main {
    public static void main(String[] args) {
        String text = "  the quick brown fox  ";
        System.out.println("original   : [" + text + "]");
        System.out.println("reversed   : [" + reverseWords(text) + "]");
        System.out.println("chars      : [" + reverseChars("tutorsbot") + "]");
        System.out.println("palindrome : " + isPalindrome("A man, a plan, a canal: Panama"));
        System.out.println("not a palindrome : " + isPalindrome("tutorsbot"));
    }

    static String reverseWords(String text) {
        String[] words = text.trim().split("\\s+");
        StringBuilder out = new StringBuilder();
        for (int i = words.length - 1; i >= 0; i--) {
            out.append(words[i]);
            if (i > 0) {
                out.append(' ');
            }
        }
        return out.toString();
    }

    static String reverseChars(String text) {
        return new StringBuilder(text).reverse().toString();
    }

    static boolean isPalindrome(String text) {
        String cleaned = text.replaceAll("[^A-Za-z0-9]", "").toLowerCase();
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }
}

The output shows the word order reversed with the whitespace normalised, the characters reversed by the StringBuilder, and the palindrome check correctly ignoring the punctuation and the case.

Two refinements that come up in discussion. The split("\\s+") pattern splits on any run of whitespace, which handles tabs and multiple spaces as well as single spaces — more robust than splitting on a literal space. And for the Unicode case, if the text can contain emoji or other supplementary characters, you should reverse by code points: convert to an int array of code points, reverse that, and convert back, rather than reversing the char array.