Question

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

Solution 1

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)

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;
  }
};

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()
  }
}