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

Question

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

How can I split by [98, 99] to get:

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

For now I only found a way to split in 2 once, but I need to split as much as the pattern [98, 99] is found:

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

Is there a way to do it via stdlib without manually looping through the collection?

Answer 1

As @BurntShushi5 suggests, use the bstr crate:

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

Playground

If you are using ( utf-8 ) bytes this may do. The idea is to use the split method from str :

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

Playground

Answer 2

AFAIK there is no split function in the std lib for byte slices (or anything else except strings really). You can however let the stdlib handle the looping for you using 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); }

Playground

This can also be adapted to work with references, thus removing the need for the inputs to implement 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]); }

Playground

Note that the output of this second version is a vector of slices instead of a vector of vectors.