Question

我正在关注Rust-wasm tutorial，我希望能够在生命游戏中轻松地将一艘船（一个真正的形状）添加到宇宙中。

作为第一步，我想将表示形状的0或1的二维数组转换为表示宇宙中形状坐标的索引向量。 / p>

我有一段工作代码，但我想让它更加用户友好：

const WIDTH: u32 = 64;
const HEIGHT: u32 = 64;

/// glider: [[0, 1, 0], [0, 0, 1], [1, 1, 1]]
fn make_ship(shape: Vec<Vec<u32>>) -> Vec<u32> {
    let mut ship: Vec<u32> = Vec::new();

    for row_idx in 0..shape.len() {
        for col_idx in 0..shape[row_idx].len() {
            let cell = shape[row_idx][col_idx];
            if cell == 1 {
                ship.push(col_idx as u32 + row_idx as u32 * WIDTH);
            }
        }
    }

    ship
}

#[test]
fn glider() {
    let glider  = vec![vec![0, 1, 0], vec![0, 0, 1], vec![1, 1, 1]];
    println!("{:?}", make_ship(glider));
}

test显示了我的问题：vec!的详细程度。理想情况下，我希望能够在没有vec!的情况下编写它。 make_ship的代码不应该关心形状数组的大小。理想的例子：

let glider = [[0, 1, 0],
              [0, 0, 1],
              [1, 1, 1],];

问题是：如何使用简单数组很好地表达形状，并使函数make_ship采用任意大小的二维向量？

Answer 1

使用自定义macro：

可以减少vec!的数量

#[macro_export]
macro_rules! vec2d {
    ($($i:expr),+) => { // handle numbers
        {
            let mut ret = Vec::new();
            $(ret.push($i);)*
            ret
        }
    };

    ([$($arr:tt),+]) => { // handle sets
        {
            let mut ret = Vec::new();
            $(ret.push(vec!($arr));)*
            ret
        }
    };
}

fn main() {
    let glider = vec2d![[0, 1, 0],
                        [0, 0, 1],
                        [1, 1, 1]];

    let glider2 = vec2d![[0, 1, 0, 1],
                         [0, 0, 1, 0],
                         [1, 1, 1, 0],
                         [0, 1, 1, 0]];


    println!("{:?}", glider);  // [[0, 1, 0], [0, 0, 1], [1, 1, 1]]
    println!("{:?}", glider2); // [[0, 1, 0, 1], [0, 0, 1, 0], [1, 1, 1, 0], [0, 1, 1, 0]]
}

在Rust的迭代器的帮助下，您的初始函数也可以使用一些改进：

fn make_ship(shape: Vec<Vec<u32>>) -> Vec<u32> {
    shape
        .iter()
        .enumerate()
        .flat_map(|(row, v)| {
            v.iter().enumerate().filter_map(move |(col, x)| {
                if *x == 1 {
                    Some(col as u32 + row as u32 * WIDTH)
                } else {
                    None
                }
            })
        })
        .collect()
}

Answer 2

Vec<Vec<_>>实际上不是二维向量，而是“向量向量”。这具有重要意义（假设外部向量被解释为行，内部被解释为列）：

行可以有不同的长度。这通常不是你想要的。
行是单个对象，可能遍布堆内存。
要访问元素，您必须遵循两个间接。

我将实现二维向量而不是一维向量，并提供有关其维度的其他信息。类似的东西：

struct Vec2D<T> {
    n_rows: usize,  // number of rows
    n_cols: usize,  // number of columns (redundant, since we know the length of data)
    data: Vec<T>,   // data stored in a contiguous 1D array
}

可以使用

let glider = Vec2D {
    n_rows: 3,
    n_cols: 3,
    data: vec![0, 1, 0, 
               0, 0, 1, 
               1, 1, 1],
};

或者更方便地使用带有数组数组的函数或宏。（见@ljedrz's answer获取灵感）。

要访问结构中的元素，您必须使用一点数学将2D索引转换为1D索引：

impl<T> Vec2D<T> {
    fn get(&self, row: usize, col: usize) -> &T {
         assert!(row < self.n_rows);
         assert!(col < self.n_cols);
         &self.data[row * self.n_cols + col]
    }
}

虽然实现自己的二维数组类型是一项有趣的练习，但为了高效使用，使用现有解决方案（如ndarray crate）可能更有效。

Answer 3

另一个解决方案是使用Vec<T>透明地处理[T]和AsRef：

fn make_ship<T>(shape: &[T]) -> Vec<u32>
where
    T: AsRef<[u32]>,
{
    let mut ship: Vec<u32> = Vec::new();

    for row_idx in 0..shape.len() {
        let row = shape[row_idx].as_ref();
        for col_idx in 0..row.len() {
            let cell = row[col_idx];
            if cell == 1 {
                ship.push(col_idx as u32 + row_idx as u32 * WIDTH);
            }
        }
    }

    ship
}

这处理以下内容：

let glider = vec![vec![0, 1, 0], vec![0, 0, 1], vec![1, 1, 1]];
let glider = [[0, 1, 0], [0, 0, 1], [1, 1, 1]];
let glider = [vec![0, 1, 0], vec![0, 0, 1], vec![1, 1, 1]];
let glider = vec![[0, 1, 0], [0, 0, 1], [1, 1, 1]];

更好的解决方案是根本不关心切片/向量，并使用迭代器：

fn make_ship<'a, T, U>(shape: &'a T) -> Vec<u32>
where
    &'a T: std::iter::IntoIterator<Item = U>,
    U: std::iter::IntoIterator<Item = &'a u32>,
{
    let mut ship: Vec<u32> = Vec::new();

    for (row_idx, row) in shape.into_iter().enumerate() {
        for (col_idx, &cell) in row.into_iter().enumerate() {
            if cell == 1 {
                ship.push(col_idx as u32 + row_idx as u32 * WIDTH);
            }
        }
    }

    ship
}

它也可以处理上面的情况，但如果它提供了这样的迭代器，也可以处理像@ kazemakase的Vec2D这样的类型。

如何方便地将二维数组转换为二维向量？

3 个答案: