# 917. Reverse Only Letters

## Description

Given a string s, reverse the string according to the following rules:

• All the characters that are not English letters remain in the same position.
• All the English letters (lowercase or uppercase) should be reversed.

Return s after reversing it.

Example 1:

Input: s = "ab-cd"
Output: "dc-ba"


Example 2:

Input: s = "a-bC-dEf-ghIj"
Output: "j-Ih-gfE-dCba"


Example 3:

Input: s = "Test1ng-Leet=code-Q!"
Output: "Qedo1ct-eeLg=ntse-T!"


Constraints:

• 1 <= s.length <= 100
• s consists of characters with ASCII values in the range [33, 122].
• s does not contain '\"' or '\\'.

## Solutions

• class Solution {
public String reverseOnlyLetters(String s) {
char[] chars = s.toCharArray();
int i = 0, j = s.length() - 1;
while (i < j) {
while (i < j && !Character.isLetter(chars[i])) {
++i;
}
while (i < j && !Character.isLetter(chars[j])) {
--j;
}
if (i < j) {
char t = chars[i];
chars[i] = chars[j];
chars[j] = t;
++i;
--j;
}
}
return new String(chars);
}
}

• class Solution {
public:
string reverseOnlyLetters(string s) {
int i = 0, j = s.size() - 1;
while (i < j) {
while (i < j && !isalpha(s[i])) ++i;
while (i < j && !isalpha(s[j])) --j;
if (i < j) {
swap(s[i], s[j]);
++i;
--j;
}
}
return s;
}
};

• class Solution:
def reverseOnlyLetters(self, s: str) -> str:
s = list(s)
i, j = 0, len(s) - 1
while i < j:
while i < j and not s[i].isalpha():
i += 1
while i < j and not s[j].isalpha():
j -= 1
if i < j:
s[i], s[j] = s[j], s[i]
i, j = i + 1, j - 1
return ''.join(s)


• func reverseOnlyLetters(s string) string {
ans := []rune(s)
i, j := 0, len(s)-1
for i < j {
for i < j && !unicode.IsLetter(ans[i]) {
i++
}
for i < j && !unicode.IsLetter(ans[j]) {
j--
}
if i < j {
ans[i], ans[j] = ans[j], ans[i]
i++
j--
}
}
return string(ans)
}

• function reverseOnlyLetters(s: string): string {
const n = s.length;
let i = 0,
j = n - 1;
let ans = [...s];
while (i < j) {
while (!/[a-zA-Z]/.test(ans[i]) && i < j) i++;
while (!/[a-zA-Z]/.test(ans[j]) && i < j) j--;
[ans[i], ans[j]] = [ans[j], ans[i]];
i++;
j--;
}
return ans.join('');
}


• impl Solution {
pub fn reverse_only_letters(s: String) -> String {
let mut cs: Vec<char> = s.chars().collect();
let n = cs.len();
let mut l = 0;
let mut r = n - 1;
while l < r {
if !cs[l].is_ascii_alphabetic() {
l += 1;
} else if !cs[r].is_ascii_alphabetic() {
r -= 1;
} else {
cs.swap(l, r);
l += 1;
r -= 1;
}
}
cs.iter().collect()
}
}