拆分 Vec<u8> 匹配一个 Vec<u8> 图案</u8></u8>

Question

let input = vec![
    1, 1, 1,
    98, 99,
    2, 2, 2, 2,
    98, 99,
    3, 3
];

如何除以[98, 99]以获得：

let output = vec![
    vec![1, 1, 1],
    vec![2, 2, 2, 2],
    vec![3, 3],
];

目前我只找到了一种拆分 2 的方法，但我需要拆分为找到模式[98, 99]的次数：

let sep = vec![98, 99];
let (a, b) = input.split_at(
    res.windows(sep.len())
        .position(|w| w == &sep)
        .unwrap_or_default(),
);

有没有一种方法可以通过 stdlib 来完成，而无需手动循环遍历集合？

Answer 1

正如@BurntShushi5 建议的那样，使用bstr板条箱：

use bstr::ByteSlice;

fn main() {
    let input: Vec<u8> = vec![1, 1, 1, 98, 99, 2, 2, 2, 2, 98, 99, 3, 3];
    let pattern: [u8; 2] = [98, 99];
    let result: Vec<Vec<u8>> = input.split_str(&pattern).map(|x|x.to_vec()).collect();
    println!("{:?}", result);
}

操场

如果您使用的是（ utf-8 ） bytes ，这可能会起作用。 这个想法是使用str的split方法：

fn main() {
    let input: Vec<u8> = vec![1, 1, 1, 98, 99, 2, 2, 2, 2, 98, 99, 3, 3];

    let s = std::str::from_utf8(&input).unwrap();
    let pattern = std::str::from_utf8(&[98, 99]).unwrap();
    let new_vector: Vec<Vec<u8>> = s.split(pattern).map(|s| s.as_bytes().to_vec()).collect();
    println!("{:?}", new_vector);
}

操场

Answer 2

AFAIK 在标准库中没有用于字节片（或除字符串之外的任何其他内容）的split function 。 但是，您可以让 stdlib 使用fold为您处理循环：

let input = vec![
    1, 1, 1,
    98, 99,
    2, 2, 2, 2,
    98, 99,
    3, 3
];
let sep = vec![ 98, 99 ];
    
let acc = input.iter().fold (
    (vec![], vec![], 0),
    |(mut res, mut cur, count), &val| {
        if val == sep[count] {
            if count+1 == sep.len() {
                res.push (cur);
                (res, vec![], 0)
            } else {
                (res, cur, count+1)
            }
        } else if count != 0 {
            cur.extend_from_slice (&sep[..count]);
            (res, cur, 0)
        } else {
            cur.push (val);
            (res, cur, 0)
        }
    });
let mut output = acc.0;
if !acc.1.is_empty() { output.push (acc.1); }

操场

这也可以适用于引用，从而无需输入来实现Copy ：

let acc = input.iter().enumerate().fold (
    (vec![], 0, 0, 0),
    |(mut res, beg, end, count), (cur, val)| {
        if val == &sep[count] {
            if count+1 == sep.len() {
                res.push (&input[beg..end]);
                (res, cur+1, cur+1, 0)
            } else {
                (res, beg, end, count+1)
            }
        } else {
            (res, beg, cur+1, 0)
        }
    });
let mut output = acc.0;
if acc.1 < acc.2 { output.push (&input[acc.1 .. acc.2]); }

操场

请注意，第二个版本的 output 是切片向量而不是向量向量。