Reverse only letters in string and keep the same order of the words

Question

I need to reverse only letters in String and keep symbols and numbers in the same place using Character.isLetter and also I need to keep the same order of the reversed words. My code reverses a string and keeps symbols and numbers in place but changes the order of the words, for example:

My input string:

a1bcd efg!h

My output string:

h1gfe dcb!a

Instead my output supposes to be:

d1cba hgf!e

class AnagramsMaker {
    public static String createAnagram(String StringToReverse) {
        char[] stringToChar = StringToReverse.toCharArray();
        int arrayStart = 0;
        int arrayEnd = stringToChar.length - 1;

        while (arrayStart < arrayEnd) {
            if (Character.isLetter(stringToChar[arrayStart]) && Character.isLetter(stringToChar[arrayEnd])) {
                char temp = stringToChar[arrayStart];
                stringToChar[arrayStart] = stringToChar[arrayEnd];
                stringToChar[arrayEnd] = temp;

                arrayStart++;
                arrayEnd--;
            }
            else if (Character.isLetter(stringToChar[arrayStart]) && !Character.isLetter(stringToChar[arrayEnd])) {
                arrayEnd--;
            }
            else if (!Character.isLetter(stringToChar[arrayStart]) && Character.isLetter(stringToChar[arrayEnd])) {
                arrayStart++;
            }
            else {
                arrayStart++;
                arrayEnd--;
            }
        }

        return String.valueOf(stringToChar);
    }
}

Answer 1

With the way you currently you have it, you don't actually need to modify your method at all and can instead utilize it to reverse each word instead of the entire String at once.

I renamed your current method to public static String createAnagramWord(String StringToReverse) and then created the method below:

public static String createAnagram(String str) {
    String anagram = "";
    String [] arr = str.split(" ");

    for (String s : arr) {
        anagram += createAnagramWord(s) + " ";
    }
    return anagram;
}

Where I use your current method with createAnagramWord(s) inside of it.

In this method note that I split the String passed to it on blank spaces with " " (you can also use \\s+ instead, see this post), and then iterate on the array returned from split using an enhanced for loop.

Inside of the for loop the new String is created by appending each reversed word along with a space.

Example Run:

public static void main(String [] args) { 
    String reverse = "a1bcd efg!h";
    System.out.println(createAnagram(reverse));
}

Output:

d1cba hgf!e

Note:
Appending String in a loop should technically utilize StringBuilder, however, I believed that is out of scope of this question and decided to omit it.

Additionally, you can rework this logic into your current method if for some reason you prefer not to separate the logic into two separate methods.

Answer 2

Here's the python solution. Take a reference for start and end of the string and then do a check if it's an alphabet, then increment the reference

def reverse_only_letters(string):
    l = 0
    r = len(string)-1
    a = list(string)
    while l<r:
        if a[l].isalpha() and a[r].isalpha():
            temp = a[l]
            a[l] = a[r]
            a[r] = temp
            l += 1
            r -= 1
        elif not a[l].isalpha():
            l += 1
        elif not a[r].isalpha():
            r -= 1
    return "".join(a)

Answer 3

    String plain = "a1bcd efg!h";

    String reversed = Arrays.stream(plain.split(" ")).map(str -> {
        char[] chars = str.toCharArray();
        int i = 0;
        int j = chars.length - 1;
        while(i < j) {
            if(Character.isLetter(chars[i]) && Character.isLetter(chars[j])) {
                char tmp = chars[i];
                chars[i] = chars[j];
                chars[j] = tmp;
                i++;
                j--;
            } else if(!Character.isLetter(chars[i]))
                i++;
            else
                j--;
        }
        return new String(chars);
    }).collect(Collectors.joining(" "));

You can do it more decleratively by taking advantage of the java streams. This code works by stepping over the special chars and reversing the places of ith and jth characters if they are both valid characters.