How do I reverse words in string that has line feed (\n or \r)?

Question

I have a string as follows:

String sentence = "I have bananas\r" +
                  "He has apples\r"  +
                  "I own 3 cars\n"   +
                  "*!"

I'd like to reverse this string so as to have an output like this:

                 "*!" +
                 "\ncars 3 own I" +
                 "\rapples has He" +
                 "\rbananas have I"

Here is a program I wrote.

public static String reverseWords(String sentence) {
    StringBuilder str = new StringBuilder();
    String[] arr = sentence.split(" ");
    for (int i = arr.length -1; i>=0; i--){
        str.append(arr[i]).append(" ");

    }
    return str.toString();

}

But I don't get the output as expected. What is wrong?

write a condition that handles the '\' character and the following character — dave, Jul 25 '18 at 14:19
@aquaballin Can you please elaborate more on this by providing a code snippet? — user7755336, Jul 25 '18 at 14:21
Read https://ericlippert.com/2014/03/05/how-to-debug-small-programs/ for tiips about how to debug your code. — Code-Apprentice, Jul 25 '18 at 17:45
@user7755336 FYI: I have updated my answer with extra information at the bottom. — Patrick Parker, Jul 26 '18 at 05:19

Patrick Parker · Accepted Answer · 2018-07-26T05:55:44.553

The problem is you are only splitting on spaces, but that is not the only type of whitespace in your sentence. You can use the pattern \s to match all whitespace. However, then you don't know what to put back in that position after the split. So instead we will split on the zero-width position in front of or behind a whitespace character.

Change your split to this:

    String[] arr = sentence.split("(?<=\\s)|(?=\\s)");

Also, now that you are preserving the whitespace characters, you no longer need to append them. So change your append to this:

        str.append(arr[i]);

The final problem is that your output will be garbled due to the presence of \r. So, if you want to see the result clearly, you should replace those characters. For example:

System.out.println(reverseWords(sentence).replaceAll("\\r","\\\\r").replaceAll("\\n","\\\\n"));

This modified code now give the desired output.

Output:

*!\ncars 3 own I\rapples has He\rbananas have I

Note:

Since you are freely mixing \r and \n, I did not add any code to treat \r\n as a special case, which means that it will be reversed to become \n\r. If that is a problem, then you will need to prevent or undo that reversal.

For example, this slightly more complex regex will prevent us from reversing any consecutive whitespace characters:

    String[] arr = sentence.split("(?<=\\s)(?!\\s)|(?<!\\s)(?=\\s)");

The above regex will match the zero-width position where there is whitespace behind but not ahead OR where there is whitespace ahead but not behind. So it won't split in the middle of consecutive whitespaces, and the order of sequences such as \r\n will be preserved.

Michael Berry · Answer 2 · 2018-07-26T09:30:18.063

Take a look at the output you're after carefully. You actually need two iteration steps here - you first need to iterate over all the lines backwards, then all the words in each line backwards. At present you're just splitting once by space (not by new line) and iterating over everything returned in that backwards, which won't do what you want!

Take a look at the example below - I've kept closely to your style and just added a second loop. It first iterates over new lines (either by \n or by \r, since split() takes a regex), then by words in each of those lines.

Note however this comes with a caveat - it won't preserve the \r and the \n. For that you'd need to use lookahead / lookbehind in your split to preserve the delimiters (see here for an example.)

public static String reverseWords(String sentence) {
    StringBuilder str = new StringBuilder();
    String[] lines = sentence.split("[\n\r]");
    for (int i = lines.length - 1; i >= 0; i--) {
        String[] words = lines[i].split(" ");
        for (int j = words.length - 1; j >= 0; j--) {
            str.append(words[j]).append(" ");
        }
        str.append("\n");
    }
    return str.toString();
}

@PatrickParker Right you are, I missed that part. I'll leave it here with the above caveat in case it's useful for anyone else who wants to achieve the above but without that condition. — Michael Berry, Jul 26 '18 at 09:30

Hearen · Answer 3 · 2018-07-26T02:13:24.317

The logic behind this question is simple, there are two steps to achieve the OP's target:

reverse the whole string;
reverse the words between (words splitted by spaces);

Instead of using StringBuilder, I'd prefer char[] to finish this, which is easy to understand.

The local test code is:

public class WordReverse {
    public static void main(String... args) {
        String s = " We have bananas\r" +
                "He has apples\r"  +
                "I own 3 cars\n"   +
                "*!";
        System.out.println(reverseSentenceThenWord(s));
    }

    /**
     * return itself if the @param s is null or empty;
     * @param s
     * @return the words (non-whitespace character compound) reversed string;
     */
    private static String reverseSentenceThenWord(String s) {
        if (s == null || s.length() == 0) return s;
        char[] arr = s.toCharArray();
        int len = arr.length;
        reverse(arr, 0, len - 1);
        boolean inWord = !isSpace(arr[0]); // used to track the start and end of a word;
        int start = inWord ? 0 : -1; // is the start valid?
        for (int i = 0; i < len; ++i) {
            if (!isSpace(arr[i])) {
                if (!inWord) {
                    inWord = true;
                    start = i; // just set the start index of the new word;
                }
            } else {
                if (inWord) { // from word to space, we do the reverse for the traversed word;
                    reverse(arr, start, i - 1);
                }
                inWord = false;
            }
        }
        if (inWord) reverse(arr, start, len - 1); // reverse the last word if it ends the sentence;
        String ret = new String(arr);
         ret = showWhiteSpaces(ret);
        // uncomment the line above to present all whitespace escape characters;
        return ret;
    }

    private static void reverse(char[] arr, int i, int j) {
        while (i < j) {
            char c = arr[i];
            arr[i] = arr[j];
            arr[j] = c;
            i++;
            j--;
        }
    }

    private static boolean isSpace(char c) {
        return String.valueOf(c).matches("\\s");
    }

    private static String showWhiteSpaces(String s) {
        String[] hidden = {"\t", "\n", "\f", "\r"};
        String[] show = {"\\\\t", "\\\\n", "\\\\f", "\\\\r"};
        for (int i = hidden.length - 1; i >= 0; i--) {
            s = s.replaceAll(hidden[i], show[i]);
        }
        return s;
    }
}

The output is not in my PC as OP provided but as:

*!
bananas have I

However, if you set a breakpoint and debug it and check the returned string, it will be as:

which is the right answer.

UPDATE

Now, if you would like to show the escaped whitespaces, you can just uncomment this line before returning the result:

// ret = showWhiteSpaces(ret);

And the final output will be exactly the same as expected in the OP's question:

*!\ncars 3 own I\rapples has He\rbananas have I

this has a few problems. the last word will not be reversed. you did not notice that because it was "I". — Patrick Parker, Jul 25 '18 at 16:58
@PatrickParker Yes, you are right. Thanks for pointing it out. Updated. Thank you ;) — Hearen, Jul 25 '18 at 23:42
also, `start < len` will always be true. you could remove that, or put `start < len-1` — Patrick Parker, Jul 26 '18 at 02:05
another problem: you should just set `inWord` to false, and initialize `start` to -1. otherwise there is an error when the length is zero, i.e. if someone passes emptry string. — Patrick Parker, Jul 26 '18 at 02:06
@PatrickParker Thanks for the advice, setting `inWord` to `false` is not a good idea, I am making sure the `inWord` and `start` are what they stand for and then we can use it as what they stand for later without caring about others - it's kind of a contract. Yes indeed, after analyzing the logic, we can remove them, while resulting in inconsistency. So I will retain them. As for the `start` in the end checking, you are correct again. since there is no way it can be larger than the `len`, we can remove it indeed. Thank you ~ — Hearen, Jul 26 '18 at 02:16

How do I reverse words in string that has line feed (\n or \r)?

3 Answers3

UPDATE