rust - 如何编写 Rust 函数来查找两个字符串之间的不同字符？

Question

字符的顺序并不重要，但数量很重要。我的意思是 aaabaaa 等于 6a + b 并且该函数类似于数学减法。例如:

fn diff(a: String, b: String) -> String {}

diff("aabbac", "accba") => "ab"
---------------------------------
"aabbac" = (3a+2b+c)
"accba" = (2a+b+2c)
(3a+2b+c) - (2a+b+2c) = a+b // -c is ignored

Answer 1

通常的技术是创建一个函数来计算每个字符出现的次数，例如 collections.Counter in Python , 并比较字符串 a 和 b 的这些数字。

Rust 标准库文档包含 snippet就可以了。这是一个接受任何迭代器的改编:

use std::collections::HashMap;
use std::hash::Hash;
use std::iter::Iterator;

fn counter<T, I>(it: I) -> HashMap<T, usize>
where
    T: Eq + Hash,
    I: Iterator<Item = T>,
{
    let mut count_by_element = HashMap::new();
    for e in it {
        *count_by_element.entry(e).or_insert(0) += 1;
    }
    count_by_element
}

现在我们知道如何构建一个映射 char -> count，我们只需要比较字符串 a 和 b 的计数>:

use std::iter;

fn diff(a: &str, b: &str) -> String {
    let mut v: Vec<char> = vec![];
    let counter_a = counter(a.chars());
    let counter_b = counter(b.chars());
    for (c, n_a) in &counter_a {
        let n_b = counter_b.get(c).unwrap_or(&0); // how many `c` in `b`?
        if n_a > n_b {
            v.extend(iter::repeat(c).take(n_a - n_b)); // add `n_a - n_b` `c`s
        }
    }
    v.into_iter().collect::<String>() // build the String
}

如果你想要一个“一次性”的功能，你可以忘记 counter 功能并使用更直接的方法:

fn diff_one_shot(a: &str, b: &str) -> String {
    let mut counter = HashMap::new();
    for c in a.chars() {
        *counter.entry(c).or_insert(0) += 1; // one more
    }
    for c in b.chars() {
        *counter.entry(c).or_insert(0) -= 1; // one less
    }
    counter
        .iter()
        .filter(|(_c, &n)| n > 0) // only if more `c` in `a` than in `b`
        .flat_map(|(c, &n)| iter::repeat(c).take(n)) // `n` times `c`
        .collect::<String>()
}

例子:

fn main() {
    println!("{:?}", counter("aaabbc".chars()));
    // {'b': 2, 'c': 1, 'a': 3}
    println!("{}", diff("aaabbc", "ab"));
    //aabc
    println!("{}", diff_one_shot("aaabbc", "ab"));
    //aacb
}