Question

917. 仅仅反转字母

English Version

题目描述

给你一个字符串 s ，根据下述规则反转字符串：

• 所有非英文字母保留在原有位置。
• 所有英文字母（小写或大写）位置反转。

返回反转后的 s_ 。_

 

示例 1：

输入：s = "ab-cd"
输出："dc-ba"

示例 2：

输入：s = "a-bC-dEf-ghIj"
输出："j-Ih-gfE-dCba"

示例 3：

输入：s = "Test1ng-Leet=code-Q!"
输出："Qedo1ct-eeLg=ntse-T!"

 

提示

• 1 <= s.length <= 100
• s 仅由 ASCII 值在范围 [33, 122] 的字符组成
• 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)

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