arrays - 如何在多个数组上创建可变循环迭代器

Question

我和我的家人一起玩 gem 棋玩得很开心，我真的很喜欢它的简单规则，但有几个问题，例如“最高分是多少”。我认为用 Rust 实现这将是一个有趣的小项目，但我陷入困境并需要帮助。

玩 gem 棋有很多规则。我想实现这个版本:https://www.youtube.com/watch?v=-A-djjimCcM .了解游戏规则可以让我更容易理解我的问题，但它可能不是解决问题的必要条件。

这是 gem 棋盘的样子:

|  |04|04|04|04|04|04|  |
|00|-----------------|00|
|  |04|04|04|04|04|04|  |

每个数字代表一个洞。较大方框左右两侧的数字代表“ gem 棋”。 gem 棋基本上是一个你计算分数的洞。右边的那个是你自己的 gem 棋，左边的那个是你对手的 gem 棋。数字代表该特定孔中弹珠的数量。

在游戏中，您可以选择一个洞，取出所有弹珠，然后将一颗弹珠放入下一个洞/ gem 棋中，直到弹珠用完为止。你跳过对手的 gem 棋。这就是我正在努力解决的问题。

我是这样解决的: gem 棋盘是一个结构，有四个存储孔的数组。一个用于玩家侧面的每个孔，一个用于他们的 gem 棋。我想将这些 Holes 数组中的三个链接在一起并循环，这样我就可以在这些 Holes 上运行相关函数(对手的 gem 棋被跳过)。这是我的代码:

pub const STARTING_MARBLES: i8 = 4;
pub const NO_OF_HOLES_OF_EACH_PLAYER: usize = 6;

// There can be two players
#[derive(Debug, Copy, Clone)]
pub enum Player {
    A,
    B,
}

// A dip in a mancala board that can contain a number of marbles
#[derive(Debug, Copy, Clone)]
struct Hole {
    marbles: i8,
}

impl Hole {
    // Adds x marbles to the hole
    fn add_x(&mut self, x: i8) {
        self.marbles += x;
    }
    // Takes all marbles from the hole and returns their number
    fn take_all(&mut self) -> i8 {
        let marbles = self.marbles;
        self.marbles = 0;
        marbles
    }
    // Returns the number of marbles in the hole
    fn count(&self) -> i8 {
        self.marbles
    }
}

// A mancala board with all its holes and mancalas to count the players points
#[derive(Debug, Copy, Clone)]
pub struct Board {
    holes_a: [Hole; NO_OF_HOLES_OF_EACH_PLAYER],
    holes_b: [Hole; NO_OF_HOLES_OF_EACH_PLAYER],
    mancala_a: [Hole; 1],
    mancala_b: [Hole; 1],
}

impl Board {
    // Create, initialize and return a new mancala board
    pub fn new() -> Self {
        let init_hole = Hole {
            marbles: STARTING_MARBLES,
        };
        let holes_a = [init_hole; NO_OF_HOLES_OF_EACH_PLAYER];
        let holes_b = [init_hole; NO_OF_HOLES_OF_EACH_PLAYER];
        let mancala_a = [Hole { marbles: 0 }];
        let mancala_b = [Hole { marbles: 0 }];
        Board {
            holes_a,
            holes_b,
            mancala_a,
            mancala_b,
        }
    }

    // Take all marbles from the chosen hole and add them to the following holes and the player's mancala
    // player: Player whos turn it is
    // no: number of the selected hole. The numbering starts with 0 on the very left hole of the player whos turn it is
    pub fn choose_hole(mut self, player: Player, no: usize) {
        let (mut players_own_holes, other_players_holes, players_mancala) = match player {
            Player::A => (self.holes_a, self.holes_b, self.mancala_a),
            Player::B => (self.holes_b, self.holes_a, self.mancala_b),
        };
        let marbles_to_spend = players_own_holes[no].take_all() as usize;
        let holes_iter = self
            .holes_a
            .iter_mut()
            .chain(self.mancala_a.iter_mut())
            .chain(self.holes_b.iter_mut())
            .cycle()
            .skip(no + 1)
            .take(marbles_to_spend);
        for mut hole in holes_iter {
            hole.add_x(1);
        }
    }
}

但是我得到以下错误:

error[E0277]: the trait bound `std::slice::IterMut<'_, Hole>: Clone` is not satisfied
    --> src/lib.rs:75:14
     |
75   |             .cycle()
     |              ^^^^^ the trait `Clone` is not implemented for `std::slice::IterMut<'_, Hole>`
     |
     = note: required because of the requirements on the impl of `Clone` for `std::iter::Chain<std::iter::Chain<std::slice::IterMut<'_, Hole>, std::slice::IterMut<'_, Hole>>, std::slice::IterMut<'_, Hole>>`
note: required by a bound in `cycle`
    --> /home/batman/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:3262:23
     |
3262 |         Self: Sized + Clone,
     |                       ^^^^^ required by this bound in `cycle`

我也尝试使用 into_iter() 方法来代替。那时我没有收到任何错误，但孔的值没有改变。我猜创建了一个副本，该方法在该副本上运行，然后该副本超出了范围，看起来什么都没有改变。

Answer 1

cycle() 迭代器方法在内部通过克隆输入迭代器、迭代克隆直到返回 None，然后用输入的另一个克隆替换克隆迭代器。这要求输入迭代器可以被克隆，但是切片元素的可变引用的迭代器不能被克隆，因为那样你就可以调用next() 在原始和克隆上，并且有两个指向相同值的可变引用。这在 Rust 中应该是不可能的，所以 std::slice::IterMut 不能被克隆，因此你不能在它上面使用 .cycle() .

解决此问题的一种方法是更改​​您的数据结构。一个元素的数组通常表示设计问题；无论如何，您可以只用一个值来完成同样的事情。

为了使这个问题更简单，只需使用一个带有循环索引的数组。像这样:

|  |12|11|10|09|08|07|  |
|13|-----------------|06|
|  |00|01|02|03|04|05|  |

所以现在你的数据结构很简单 struct Board { holes: [Hole; 14] }。

遍历这个数据结构现在变得非常简单——你只需执行 (0..14).cycle() 即可获得数组索引的重复迭代器。

使用此数据结构时，我们需要处理在分布弹珠时跳过对手的 gem 棋的游戏规则。我们可以通过简单的 match、skip 和 filter 来处理这个问题，以及从棋盘的哪一侧开始:

let (opponent_mancala_index, start_idx) = match player {
    Player::A => (13, 0),
    Player::B => (6, 7),
};

let indexes = (0..14)
    .cycle()
    .skip(no + start_idx)
    .filter(|&v| v != opponent_mancala_index)
    .take(marbles_to_spend);

for i in indexes {
    self.holes[i].add_x(1);
}

您可能会考虑将这些特殊索引命名为常量。

另外，请注意您的 Board::choose_hole() 函数应该采用 &mut self 而不是 mut self，否则您将进行更改到副本，然后丢弃该副本。