如何在字符串中交换两个字符？

Question

我想写一个函数如下:

• 输入:字符串A,int i,0 <i <len(A)
• 输出:字符串A,字符位于(i - 1),交换字符位于i.

什么是干净的解决方案,将实现这一目标？我目前的解决方案是:

let mut swapped = input_str[0..i].to_string();
swapped.push(input_str.char_at(i));
swapped.push(input_str.char_at(i - 1));
swapped.push_str(&query[i..input_str.len()]);

但这只适用于ASCII字符串.我可以把其他解决方案想象成转换为UTF-32中的向量,交换并转换回字符串,但它看起来像是一项额外的工作.

Answer 1

这是一个非常好的解决方案:

use std::str::CharRange;

fn swap_chars_at(input_str: &str, i: usize) -> String {
    // Pre-allocate a string of the correct size
    let mut swapped = String::with_capacity(input_str.len());
    // Pluck the previous character
    let CharRange { ch: prev_ch, next: prev } = input_str.char_range_at_reverse(i);
    // Pluck the current character
    let CharRange { ch, next } = input_str.char_range_at(i);
    // Put them back
    swapped.push_str(&input_str[..prev]);
    swapped.push(ch);
    swapped.push(prev_ch);
    swapped.push_str(&input_str[next..]);
    // Done!
    swapped
}

#[test]
fn smoke_test() {
    let s = swap_chars_at("lyra", 2);
    assert_eq!(s, "lrya");
}

#[test]
fn unicode() {
    // 'ç' takes up 2 bytes in UTF-8
    let s = swap_chars_at("ça va?", 2);
    assert_eq!(s, "aç va?");
}

从文档:

• fn char_range_at(&self, start: usize) -> CharRange
  • 从字符串中取出一个字符并返回下一个字符的索引.
• fn char_range_at_reverse(&self, start: usize) -> CharRange
  • 给定一个字节位置和一个str,返回前一个char及其位置.

总之,这两种方法让我们在字符串中向后和向前窥视 - 这正是我们想要的.

但等等,还有更多!DK用上面的代码指出了一个角落案例.如果输入包含任何组合字符,则它们可能与它们组合的字符分开.

现在,这个问题是关于Rust,而不是Unicode,所以我不会详细介绍它是如何工作的.您现在需要知道的是Rust提供了这种方法:

• fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices
  • 返回self 的字形集群及其字节偏移量的迭代器.

随着一个健康的应用.find()和.rev(),我们到达了这个(希望)正确的解决方法:

#![allow(unstable)]  // `GraphemeIndices` is unstable

fn swap_graphemes_at(input_str: &str, i: usize) -> String {
    // Pre-allocate a string of the correct size
    let mut swapped = String::with_capacity(input_str.len());
    // Find the grapheme at index i
    let (_, gr) = input_str.grapheme_indices(true)
        .find(|&(index, _)| index == i)
        .expect("index does not point to a valid grapheme");
    // Find the grapheme just before it
    let (prev, prev_gr) = input_str.grapheme_indices(true).rev()
        .find(|&(index, _)| index < i)
        .expect("no graphemes to swap with");
    // Put it all back together
    swapped.push_str(&input_str[..prev]);
    swapped.push_str(gr);
    swapped.push_str(prev_gr);
    swapped.push_str(&input_str[i+gr.len()..]);
    // Done!
    swapped
}

#[test]
fn combining() {
    // Ensure that "c\u{327}" is treated as a single unit
    let s = swap_graphemes_at("c\u{327}a va?", 3);
    assert_eq!(s, "ac\u{327} va?");
}

不可否认,这有点令人费解.首先,它迭代输入,从中取出字形集群i.然后它通过输入向后迭代(.rev()),选择带有索引的最右边的簇< i(即前一个簇).最后,它将所有东西重新组合在一起.

如果你真的很迂腐,还有更多特殊情况需要处理.例如,如果字符串包含Windows换行符("\r\n"),那么我们可能不想交换它们.在希腊语中,字母sigma(σ)在单词(ς)的末尾以不同的方式书写,因此更好的算法应根据需要在它们之间进行转换.不要忘记那些双向控制字符 ......

但为了我们的理智,我们会停在这里.