Rust 练习册 62：保龄球计分与状态机实现

原创 已于 2025-11-21 14:30:04 修改 · 633 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#rust #网络 #开发语言

于 2025-11-20 12:12:24 首次发布

在体育运动中，计分规则往往比想象中更加复杂。保龄球就是这样一个例子，它的计分系统包含了多种特殊情况，如补中（spare）、全中（strike）等，这些都会影响最终得分的计算。在 Exercism 的 “bowling” 练习中，我们将实现一个完整的保龄球计分系统，这不仅能帮助我们掌握复杂状态管理技巧，还能深入学习 Rust 中的状态机设计和错误处理机制。

保龄球计分规则

保龄球比赛由10轮（frames）组成，每轮玩家最多投球2次（除非是补中或全中）。计分规则如下：

  1. 普通轮次：两次投球击倒的瓶数直接相加
  2. 补中（Spare）：一轮中两次投球击倒所有10个瓶，得分为10 + 下一次投球击倒的瓶数
  3. 全中（Strike）：第一次投球就击倒所有10个瓶，得分为10 + 下两次投球击倒的瓶数
  4. 第10轮特殊规则：
    • 如果是补中，玩家可以额外投球1次
    • 如果是全中，玩家可以额外投球2次

让我们先看看练习提供的结构和函数签名：

#[derive(Debug, PartialEq)]
pub enum Error {
    NotEnoughPinsLeft,
    GameComplete,
}

pub struct BowlingGame {}

impl BowlingGame {
    pub fn new() -> Self {
        unimplemented!();
    }

    pub fn roll(&mut self, pins: u16) -> Result<(), Error> {
        unimplemented!("Record that {} pins have been scored", pins);
    }

    pub fn score(&self) -> Option<u16> {
        unimplemented!("Return the score if the game is complete, or None if not.");
    }
}

我们需要实现这个结构体，它应该能够：

  1. 跟踪游戏状态
  2. 记录每次投球的结果
  3. 根据规则计算得分
  4. 处理各种错误情况

算法设计

1. 数据结构设计

#[derive(Debug, PartialEq)]
pub enum Error {
    NotEnoughPinsLeft,
    GameComplete,
}

#[derive(Debug, Clone)]
enum Frame {
    InProgress { rolls: Vec<u16> },
    Complete { rolls: Vec<u16> },
}

pub struct BowlingGame {
    frames: Vec<Frame>,
    current_frame: usize,
}

impl BowlingGame {
    pub fn new() -> Self {
        let mut frames = Vec::with_capacity(10);
        for _ in 0..10 {
            frames.push(Frame::InProgress { rolls: Vec::with_capacity(2) });
        }
        
        BowlingGame {
            frames,
            current_frame: 0,
        }
    }

    pub fn roll(&mut self, pins: u16) -> Result<(), Error> {
        // 检查游戏是否已完成
        if self.is_game_complete() {
            return Err(Error::GameComplete);
        }
        
        // 检查投球是否有效
        if pins > 10 {
            return Err(Error::NotEnoughPinsLeft);
        }
        
        // 获取当前轮次
        let current_frame_index = self.current_frame;
        if let Frame::InProgress { rolls } = &mut self.frames[current_frame_index] {
            // 检查当前轮次是否还能投球
            if current_frame_index < 9 {
                // 前9轮的规则
                if rolls.is_empty() {
                    // 第一次投球
                    if pins <= 10 {
                        rolls.push(pins);
                        // 如果是全中，完成本轮
                        if pins == 10 {
                            self.frames[current_frame_index] = Frame::Complete { rolls: rolls.clone() };
                            self.current_frame += 1;
                        }
                    } else {
                        return Err(Error::NotEnoughPinsLeft);
                    }
                } else {
                    // 第二次投球
                    if rolls[0] + pins <= 10 {
                        rolls.push(pins);
                        self.frames[current_frame_index] = Frame::Complete { rolls: rolls.clone() };
                        self.current_frame += 1;
                    } else {
                        return Err(Error::NotEnoughPinsLeft);
                    }
                }
            } else {
                // 第10轮的特殊规则
                self.handle_tenth_frame(pins, rolls)?;
            }
        } else {
            return Err(Error::GameComplete);
        }
        
        Ok(())
    }

    pub fn score(&self) -> Option<u16> {
        // 检查游戏是否已完成
        if !self.is_game_complete() {
            return None;
        }
        
        let mut total_score = 0;
        
        for (i, frame) in self.frames.iter().enumerate() {
            if let Frame::Complete { rolls } = frame {
                let frame_score = rolls.iter().sum::<u16>();
                total_score += frame_score;
                
                // 计算奖励分
                if i < 9 { // 前9轮才需要计算奖励
                    if rolls.len() == 1 && rolls[0] == 10 {
                        // 全中
                        total_score += self.strike_bonus(i);
                    } else if rolls.len() == 2 && rolls[0] + rolls[1] == 10 {
                        // 补中
                        total_score += self.spare_bonus(i);
                    }
                }
            } else {
                // 如果有任何轮次未完成，游戏未结束
                return None;
            }
        }
        
        Some(total_score)
    }
    
    fn is_game_complete(&self) -> bool {
        if self.current_frame < 9 {
            return false;
        }
        
        if self.current_frame > 9 {
            return true;
        }
        
        // 检查第10轮是否完成
        matches!(self.frames[9], Frame::Complete { .. })
    }
    
    fn strike_bonus(&self, frame_index: usize) -> u16 {
        if frame_index >= 9 {
            return 0;
        }
        
        let next_frame = &self.frames[frame_index + 1];
        match next_frame {
            Frame::Complete { rolls } => {
                if rolls.len() >= 2 {
                    rolls[0] + rolls[1]
                } else if rolls.len() == 1 {
                    // 下一轮也是全中
                    let next_next_frame = &self.frames[frame_index + 2];
                    if let Frame::Complete { rolls: next_next_rolls } = next_next_frame {
                        if !next_next_rolls.is_empty() {
                            rolls[0] + next_next_rolls[0]
                        } else {
                            0
                        }
                    } else {
                        0
                    }
                } else {
                    0
                }
            }
            _ => 0,
        }
    }
    
    fn spare_bonus(&self, frame_index: usize) -> u16 {
        if frame_index >= 9 {
            return 0;
        }
        
        let next_frame = &self.frames[frame_index + 1];
        if let Frame::Complete { rolls } = next_frame {
            if !rolls.is_empty() {
                rolls[0]
            } else {
                0
            }
        } else {
            0
        }
    }
    
    fn handle_tenth_frame(&mut self, pins: u16, rolls: &mut Vec<u16>) -> Result<(), Error> {
        match rolls.len() {
            0 => {
                // 第一次投球
                rolls.push(pins);
                if pins < 10 {
                    // 不是全中，还可以继续投
                    Ok(())
                } else {
                    // 全中，还需要投两次
                    Ok(())
                }
            }
            1 => {
                // 第二次投球
                if rolls[0] == 10 {
                    // 第一次是全中
                    if pins <= 10 {
                        rolls.push(pins);
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else {
                    // 第一次不是全中
                    if rolls[0] + pins <= 10 {
                        rolls.push(pins);
                        if rolls[0] + pins < 10 {
                            // 普通完成
                            self.frames[self.current_frame] = Frame::Complete { rolls: rolls.clone() };
                            self.current_frame += 1;
                            Ok(())
                        } else {
                            // 补中，还需要再投一次
                            Ok(())
                        }
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                }
            }
            2 => {
                // 第三次投球（仅在第10轮可能）
                if rolls[0] == 10 && rolls[1] < 10 {
                    // 第一次全中，第二次不是全中
                    if rolls[1] + pins <= 10 {
                        rolls.push(pins);
                        self.frames[self.current_frame] = Frame::Complete { rolls: rolls.clone() };
                        self.current_frame += 1;
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else if rolls[0] == 10 && rolls[1] == 10 {
                    // 连续两次全中
                    if pins <= 10 {
                        rolls.push(pins);
                        self.frames[self.current_frame] = Frame::Complete { rolls: rolls.clone() };
                        self.current_frame += 1;
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else if rolls[0] + rolls[1] == 10 {
                    // 补中
                    if pins <= 10 {
                        rolls.push(pins);
                        self.frames[self.current_frame] = Frame::Complete { rolls: rolls.clone() };
                        self.current_frame += 1;
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else {
                    Err(Error::GameComplete)
                }
            }
            _ => Err(Error::GameComplete),
        }
    }
}

简化实现

上面的实现较为复杂，让我们尝试一个更简洁的版本：

#[derive(Debug, PartialEq)]
pub enum Error {
    NotEnoughPinsLeft,
    GameComplete,
}

pub struct BowlingGame {
    rolls: Vec<u16>,
}

impl BowlingGame {
    pub fn new() -> Self {
        BowlingGame {
            rolls: Vec::new(),
        }
    }

    pub fn roll(&mut self, pins: u16) -> Result<(), Error> {
        // 检查游戏是否已完成
        if self.score().is_some() {
            return Err(Error::GameComplete);
        }
        
        // 检查投球是否有效
        if pins > 10 {
            return Err(Error::NotEnoughPinsLeft);
        }
        
        // 检查当前投球是否合法
        let roll_index = self.rolls.len();
        
        // 检查是否违反每轮的瓶数限制
        if roll_index >= 2 {
            let frame_index = roll_index / 2;
            
            // 如果不是第10轮且不是额外投球
            if frame_index < 9 {
                // 如果前一次是全中，则当前是新轮次
                let is_strike = roll_index % 2 == 1 && self.rolls[roll_index - 1] == 10;
                
                if !is_strike {
                    // 检查本轮总瓶数
                    let current_frame_start = frame_index * 2;
                    let frame_total = self.rolls[current_frame_start] + pins;
                    if frame_total > 10 {
                        return Err(Error::NotEnoughPinsLeft);
                    }
                }
            } else if frame_index == 9 {
                // 第10轮的特殊规则
                self.validate_tenth_frame(roll_index, pins)?;
            }
        }
        
        self.rolls.push(pins);
        Ok(())
    }

    pub fn score(&self) -> Option<u16> {
        if self.rolls.len() < 12 {
            // 至少需要12次投球才可能完成游戏（9轮零投球 + 第10轮至少2次投球）
            // 但实际可能需要更多，取决于是否是全中或补中
            let mut complete_frames = 0;
            let mut roll_index = 0;
            
            while complete_frames < 10 && roll_index < self.rolls.len() {
                if roll_index + 1 < self.rolls.len() {
                    if self.rolls[roll_index] == 10 {
                        // 全中
                        complete_frames += 1;
                        roll_index += 1;
                    } else if self.rolls[roll_index] + self.rolls[roll_index + 1] == 10 {
                        // 补中
                        if roll_index + 2 < self.rolls.len() {
                            complete_frames += 1;
                            roll_index += 2;
                        } else {
                            // 还需要额外投球
                            return None;
                        }
                    } else {
                        // 普通轮次
                        complete_frames += 1;
                        roll_index += 2;
                    }
                } else {
                    // 只有一次投球记录，游戏未完成
                    return None;
                }
            }
            
            if complete_frames < 10 {
                return None;
            }
        }
        
        let mut score = 0;
        let mut roll_index = 0;
        let mut frame = 0;
        
        while frame < 10 {
            if roll_index >= self.rolls.len() {
                return None;
            }
            
            if self.rolls[roll_index] == 10 {
                // 全中
                if roll_index + 2 < self.rolls.len() {
                    score += 10 + self.rolls[roll_index + 1] + self.rolls[roll_index + 2];
                    roll_index += 1;
                } else {
                    return None;
                }
            } else if roll_index + 1 < self.rolls.len() 
                && self.rolls[roll_index] + self.rolls[roll_index + 1] == 10 {
                // 补中
                if roll_index + 2 < self.rolls.len() {
                    score += 10 + self.rolls[roll_index + 2];
                    roll_index += 2;
                } else {
                    return None;
                }
            } else if roll_index + 1 < self.rolls.len() {
                // 普通轮次
                score += self.rolls[roll_index] + self.rolls[roll_index + 1];
                roll_index += 2;
            } else {
                return None;
            }
            
            frame += 1;
        }
        
        Some(score)
    }
    
    fn validate_tenth_frame(&self, roll_index: usize, pins: u16) -> Result<(), Error> {
        let rolls_in_tenth = roll_index - 18; // 前9轮18次投球
        
        match rolls_in_tenth {
            0 => {
                // 第10轮第一次投球，总是合法的
                Ok(())
            }
            1 => {
                // 第10轮第二次投球
                if self.rolls[18] == 10 {
                    // 第一次是全中，第二次最多10个瓶
                    if pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else {
                    // 第一次不是全中，两次总和不能超过10
                    if self.rolls[18] + pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                }
            }
            2 => {
                // 第10轮第三次投球
                if self.rolls[18] == 10 && self.rolls[19] < 10 {
                    // 第一次全中，第二次不是全中
                    if self.rolls[19] + pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else if self.rolls[18] + self.rolls[19] == 10 {
                    // 补中
                    if pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else if self.rolls[18] == 10 && self.rolls[19] == 10 {
                    // 连续两次全中
                    if pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else {
                    Err(Error::NotEnoughPinsLeft)
                }
            }
            _ => Err(Error::NotEnoughPinsLeft),
        }
    }
}

测试用例分析

通过查看测试用例，我们可以更好地理解需求：

#[test]
fn you_cannot_roll_more_than_ten_pins_in_a_single_roll() {
    let mut game = BowlingGame::new();

    assert_eq!(game.roll(11), Err(Error::NotEnoughPinsLeft));
}

单次投球不能超过10个瓶。

#[test]
fn a_game_score_is_some_if_ten_frames_have_been_rolled() {
    let mut game = BowlingGame::new();

    for _ in 0..10 {
        let _ = game.roll(0);
        let _ = game.roll(0);
    }

    assert!(game.score().is_some());
}

完成10轮后可以计算得分。

#[test]
fn spare_in_the_first_frame_followed_by_zeros() {
    let mut game = BowlingGame::new();

    let _ = game.roll(6);
    let _ = game.roll(4);

    for _ in 0..18 {
        let _ = game.roll(0);
    }

    assert_eq!(game.score(), Some(10));
}

补中的得分是10 + 下一次投球得分。

#[test]
fn points_scored_in_the_two_rolls_after_a_strike_are_counted_twice_as_a_bonus() {
    let mut game = BowlingGame::new();

    let _ = game.roll(10);
    let _ = game.roll(5);
    let _ = game.roll(3);

    for _ in 0..16 {
        let _ = game.roll(0);
    }

    assert_eq!(game.score(), Some(26));
}

全中的得分是10 + 后两次投球得分。

#[test]
fn all_strikes_is_a_perfect_score_of_300() {
    let mut game = BowlingGame::new();

    for _ in 0..12 {
        let _ = game.roll(10);
    }

    assert_eq!(game.score(), Some(300));
}

完美游戏（12次全中）得分为300分。

完整实现

考虑所有边界情况的完整实现：

#[derive(Debug, PartialEq)]
pub enum Error {
    NotEnoughPinsLeft,
    GameComplete,
}

pub struct BowlingGame {
    rolls: Vec<u16>,
}

impl BowlingGame {
    pub fn new() -> Self {
        BowlingGame {
            rolls: Vec::new(),
        }
    }

    pub fn roll(&mut self, pins: u16) -> Result<(), Error> {
        // 检查游戏是否已完成
        if self.is_game_complete() {
            return Err(Error::GameComplete);
        }
        
        // 检查投球是否有效
        if pins > 10 {
            return Err(Error::NotEnoughPinsLeft);
        }
        
        // 检查当前投球是否违反规则
        let roll_index = self.rolls.len();
        
        if roll_index >= 2 {
            let frame_index = roll_index / 2;
            
            if frame_index < 9 {
                // 前9轮
                let is_strike = roll_index % 2 == 1 && self.rolls[roll_index - 1] == 10;
                
                if !is_strike {
                    // 检查本轮总瓶数
                    let current_frame_start = frame_index * 2;
                    let frame_total = self.rolls[current_frame_start] + pins;
                    if frame_total > 10 {
                        return Err(Error::NotEnoughPinsLeft);
                    }
                }
            } else if frame_index == 9 {
                // 第10轮特殊规则
                self.validate_tenth_frame_roll(pins)?;
            }
        }
        
        self.rolls.push(pins);
        Ok(())
    }

    pub fn score(&self) -> Option<u16> {
        if !self.is_game_complete() {
            return None;
        }
        
        let mut score = 0;
        let mut roll_index = 0;
        let mut frame = 0;
        
        while frame < 10 {
            if roll_index >= self.rolls.len() {
                return None;
            }
            
            if self.rolls[roll_index] == 10 {
                // 全中
                if roll_index + 2 < self.rolls.len() {
                    score += 10 + self.rolls[roll_index + 1] + self.rolls[roll_index + 2];
                    roll_index += 1;
                } else {
                    return None;
                }
            } else if roll_index + 1 < self.rolls.len() 
                && self.rolls[roll_index] + self.rolls[roll_index + 1] == 10 {
                // 补中
                if roll_index + 2 < self.rolls.len() {
                    score += 10 + self.rolls[roll_index + 2];
                    roll_index += 2;
                } else {
                    return None;
                }
            } else if roll_index + 1 < self.rolls.len() {
                // 普通轮次
                score += self.rolls[roll_index] + self.rolls[roll_index + 1];
                roll_index += 2;
            } else {
                return None;
            }
            
            frame += 1;
        }
        
        Some(score)
    }
    
    fn is_game_complete(&self) -> bool {
        let mut complete_frames = 0;
        let mut roll_index = 0;
        
        while complete_frames < 10 && roll_index < self.rolls.len() {
            if roll_index + 1 < self.rolls.len() {
                if self.rolls[roll_index] == 10 {
                    // 全中
                    complete_frames += 1;
                    roll_index += 1;
                    
                    // 第10轮全中需要额外检查
                    if complete_frames == 10 && roll_index < self.rolls.len() {
                        // 需要确保有足够的额外投球
                        if roll_index + 1 >= self.rolls.len() {
                            return false;
                        }
                    }
                } else if self.rolls[roll_index] + self.rolls[roll_index + 1] == 10 {
                    // 补中
                    if roll_index + 2 < self.rolls.len() {
                        complete_frames += 1;
                        roll_index += 2;
                    } else {
                        // 还需要额外投球
                        return false;
                    }
                } else {
                    // 普通轮次
                    complete_frames += 1;
                    roll_index += 2;
                }
            } else {
                // 只有一次投球记录，游戏未完成
                return false;
            }
        }
        
        complete_frames >= 10
    }
    
    fn validate_tenth_frame_roll(&self, pins: u16) -> Result<(), Error> {
        let tenth_frame_rolls = &self.rolls[18..]; // 前9轮18次投球
        let roll_count = tenth_frame_rolls.len();
        
        match roll_count {
            0 => Ok(()), // 第一次投球总是合法
            1 => {
                // 第二次投球
                if tenth_frame_rolls[0] == 10 {
                    // 第一次是全中
                    if pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else {
                    // 第一次不是全中
                    if tenth_frame_rolls[0] + pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                }
            }
            2 => {
                // 第三次投球
                if tenth_frame_rolls[0] == 10 && tenth_frame_rolls[1] < 10 {
                    // 第一次全中，第二次不是全中
                    if tenth_frame_rolls[1] + pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else if tenth_frame_rolls[0] + tenth_frame_rolls[1] == 10 {
                    // 补中
                    if pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else if tenth_frame_rolls[0] == 10 && tenth_frame_rolls[1] == 10 {
                    // 连续两次全中
                    if pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else {
                    Err(Error::NotEnoughPinsLeft)
                }
            }
            _ => Err(Error::NotEnoughPinsLeft),
        }
    }
}

错误处理和边界情况

考虑更多边界情况的实现：

#[derive(Debug, PartialEq)]
pub enum Error {
    NotEnoughPinsLeft,
    GameComplete,
}

pub struct BowlingGame {
    rolls: Vec<u16>,
}

impl BowlingGame {
    pub fn new() -> Self {
        BowlingGame {
            rolls: Vec::new(),
        }
    }

    pub fn roll(&mut self, pins: u16) -> Result<(), Error> {
        // 检查游戏是否已完成
        if self.is_game_complete() {
            return Err(Error::GameComplete);
        }
        
        // 检查投球是否有效
        if pins > 10 {
            return Err(Error::NotEnoughPinsLeft);
        }
        
        // 检查当前投球是否违反规则
        let roll_index = self.rolls.len();
        
        if roll_index >= 2 {
            let frame_index = roll_index / 2;
            
            if frame_index < 9 {
                // 前9轮
                let is_strike = roll_index % 2 == 1 && self.rolls[roll_index - 1] == 10;
                
                if !is_strike {
                    // 检查本轮总瓶数
                    let current_frame_start = frame_index * 2;
                    let frame_total = self.rolls[current_frame_start] + pins;
                    if frame_total > 10 {
                        return Err(Error::NotEnoughPinsLeft);
                    }
                }
            } else if frame_index == 9 {
                // 第10轮特殊规则
                self.validate_tenth_frame(roll_index, pins)?;
            }
        }
        
        self.rolls.push(pins);
        Ok(())
    }

    pub fn score(&self) -> Option<u16> {
        if !self.is_game_complete() {
            return None;
        }
        
        let mut score = 0;
        let mut roll_index = 0;
        let mut frame = 0;
        
        while frame < 10 {
            if roll_index >= self.rolls.len() {
                return None;
            }
            
            if self.rolls[roll_index] == 10 {
                // 全中
                if roll_index + 2 < self.rolls.len() {
                    score += 10 + self.rolls[roll_index + 1] + self.rolls[roll_index + 2];
                    roll_index += 1;
                } else {
                    return None;
                }
            } else if roll_index + 1 < self.rolls.len() 
                && self.rolls[roll_index] + self.rolls[roll_index + 1] == 10 {
                // 补中
                if roll_index + 2 < self.rolls.len() {
                    score += 10 + self.rolls[roll_index + 2];
                    roll_index += 2;
                } else {
                    return None;
                }
            } else if roll_index + 1 < self.rolls.len() {
                // 普通轮次
                score += self.rolls[roll_index] + self.rolls[roll_index + 1];
                roll_index += 2;
            } else {
                return None;
            }
            
            frame += 1;
        }
        
        Some(score)
    }
    
    fn is_game_complete(&self) -> bool {
        // 检查是否完成10轮
        let mut frames_completed = 0;
        let mut i = 0;
        
        while frames_completed < 10 && i < self.rolls.len() {
            if i + 1 < self.rolls.len() {
                if self.rolls[i] == 10 {
                    // 全中
                    frames_completed += 1;
                    i += 1;
                } else if self.rolls[i] + self.rolls[i + 1] == 10 {
                    // 补中
                    if i + 2 < self.rolls.len() {
                        frames_completed += 1;
                        i += 2;
                    } else {
                        return false; // 还需要额外投球
                    }
                } else {
                    // 普通轮次
                    frames_completed += 1;
                    i += 2;
                }
            } else {
                return false; // 投球次数不足
            }
        }
        
        frames_completed >= 10
    }
    
    fn validate_tenth_frame(&self, roll_index: usize, pins: u16) -> Result<(), Error> {
        let tenth_frame_start = 18; // 前9轮共18次投球
        if roll_index < tenth_frame_start {
            return Ok(());
        }
        
        let tenth_rolls: &[u16] = &self.rolls[tenth_frame_start..];
        let current_roll_in_tenth = roll_index - tenth_frame_start;
        
        match current_roll_in_tenth {
            0 => Ok(()), // 第一次投球总是合法
            1 => {
                // 第二次投球
                if tenth_rolls[0] == 10 {
                    // 第一次是全中
                    if pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else {
                    // 第一次不是全中
                    if tenth_rolls[0] + pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                }
            }
            2 => {
                // 第三次投球
                if tenth_rolls.len() < 3 {
                    return Err(Error::NotEnoughPinsLeft);
                }
                
                if tenth_rolls[0] == 10 && tenth_rolls[1] < 10 {
                    // 第一次全中，第二次不是全中
                    if tenth_rolls[1] + pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else if tenth_rolls[0] + tenth_rolls[1] == 10 {
                    // 补中
                    if pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else if tenth_rolls[0] == 10 && tenth_rolls[1] == 10 {
                    // 连续两次全中
                    if pins <= 10 {
                        Ok(())
                    } else {
                        Err(Error::NotEnoughPinsLeft)
                    }
                } else {
                    Err(Error::NotEnoughPinsLeft)
                }
            }
            _ => Err(Error::NotEnoughPinsLeft),
        }
    }
}

实际应用场景

保龄球计分系统在实际开发中有以下应用：

  1. 体育应用：保龄球馆的计分系统
  2. 游戏开发：体育类游戏的计分逻辑
  3. 状态机实现：复杂业务逻辑的状态管理
  4. 规则引擎：基于规则的计算系统

算法复杂度分析

  1. 时间复杂度：

    • roll 操作：O(1)
    • score 操作：O(n)，其中 n 是投球次数（最多21次）

  2. 空间复杂度：O(n)，存储所有投球记录

与其他实现方式的比较

// 使用面向对象的状态模式实现
trait FrameState {
    fn roll(&mut self, pins: u16) -> Result<(), Error>;
    fn is_complete(&self) -> bool;
    fn score(&self) -> u16;
}

struct InProgressFrame {
    rolls: Vec<u16>,
}

struct CompleteFrame {
    rolls: Vec<u16>,
    bonus: u16,
}

// 状态模式实现更加复杂，但对于某些场景可能更清晰

总结

通过 bowling 练习，我们学到了：

  1. 状态管理：掌握了复杂游戏状态的跟踪和管理
  2. 规则实现：学会了如何将复杂的业务规则转换为代码
  3. 错误处理：熟练使用 Result 类型处理各种错误情况
  4. 边界处理：理解了如何处理各种边界情况和特殊规则
  5. 算法设计：了解了游戏计分算法的设计思路
  6. 测试驱动：通过丰富的测试用例确保实现的正确性

这些技能在实际开发中非常有用，特别是在实现复杂业务逻辑、游戏系统和状态管理应用时。保龄球计分虽然看起来简单，但它涉及到了状态机设计、规则实现和复杂逻辑处理等许多核心概念，是学习 Rust 系统设计的良好起点。

通过这个练习，我们也看到了 Rust 在处理复杂状态和错误处理方面的强大能力，以及如何用安全且清晰的方式表达复杂的业务规则。这种结合了安全性和表达力的语言特性正是 Rust 的魅力所在。

ImportError: DLL load failed while importing _rust: 找不到指定的程序的解决方案
weixin_43178406的博客
08-09 19万+
 本文主要介绍了ImportError: DLL load failed while importing _rust: 找不到指定的程序的解决方案，希望能对使用Python的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
safetensors_rust.SafetensorError: Error while deserializing header: MetadataIncompleteBuffer解决方案
热门推荐
weixin_43178406的博客
09-14 15万+
本文主要介绍了safetensors_rust.SafetensorError: Error while deserializing header: MetadataIncompleteBuffer解决方案，希望能对使用Python的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案 2.1 Windows 2.2 Linux
Rust入门：基础语法应用
优快云博客专家，系统架构师，有合作、疑惑请私信博主。
11-13 7万+
本文围绕 Rust 基础语法展开，涵盖变量、数据类型、函数、控制流等核心概念，还介绍了所有权、结构体、枚举、模式匹配、错误处理、生命周期及重影等特色内容。Rust 是强类型且静态类型语言，变量默认不可变需用mut声明，支持自动类型推断也可指定类型。其独特的所有权机制保障内存安全，通过借用和引用实现数据共享，生命周期确保引用有效。结构体可自定义类型，枚举描述多种可能类型，模式匹配高效处理枚举值，Result 和 Option 枚举助力错误处理，重影则允许变量名复用且能改变类型与属性……
Rust入门：运算符和数据类型应用
优快云博客专家，系统架构师，有合作、疑惑请私信博主。
11-13 7万+
本文围绕 Rust 运算符与数据类型展开详细讲解，先介绍了算术、关系、逻辑、位运算、赋值与复合赋值及其他常见运算符，包括各自的功能、示例与使用细节，如乘方需用 pow 或 powf 方法，无 ** 运算符。接着阐述数据类型，涵盖整数型（按位长和有无符号分类，含特殊的 isize 与 usize）、浮点数型（f32 与 f64，默认 f64）、布尔型、字符型（4 字节，支持 Unicode），以及复合类型元组（可存不同类型数据）和数组（同类型数据，默认不可变）。
2024 Rust现代实用教程：1.1Rust简介与安装更新
喜欢打篮球的普通人
10-21 5075
输入cargo ，按两下 tab键，进行命令补全提示，可以看到命令已经出来了。1 使用默认配置，2 使用自定义配置，3 取消安装。Windows 的 Linux 子系统（WSL）好了，rust环境已经安装成功了！这里我们选择默认配置输入 1。配置cargo的环境变量。
Rust 异步编程实战：手把手搭建 Tokio 服务器
定期分享我的发现和想法，感谢你的陪伴和支持
11-13 1万+
这个tokio示例清晰地表明，Rust 的“学习曲线”（所有权、生命周期）并不是学术上的“象牙塔”，而是构建高可靠并发系统的“安全带”。这一行代码的背后，是所有权（move）、生命周期（防止悬垂引用）和 Trait（Send）的协同工作。编译器在编译期为你处理了所有 C++ 和 Go 开发者必须在运行时（通过 Mutex、Channel 或肉眼）担心的内存安全和数据竞争问题。当你点击“编译”通过时，你就已经消除了整整一个类别的并发 Bug。hello，我是是Yu欸。原文链接 👉 ，⚡️更新更及时。
Rust开发之路：从入门到实践的全面指南
一键难忘的博客
08-29 4157
首先，我们定义一个Taskid: u32,Task {id,Task结构体包含任务的ID、描述和是否完成的状态。Rust是一门独特且充满挑战的编程语言。通过深入学习Rust，我们不仅可以掌握系统编程的核心知识，还能在高性能应用开发中得心应手。从基础的内存安全管理到高级的并发编程，从简单的工具开发到复杂的Web应用，Rust为开发者提供了丰富的可能性。在这篇文章中，我分享了从零开始学习Rust的过程，探讨了Rust的独特特性和学习心得，并通过实际项目展示了Rust的应用。
用 Rust 打造二维码艺术大师：从想法到实现
百锦再的博客
11-16 2万+
本文介绍了一个用Rust实现的二维码艺术生成器项目(qr-artist)，旨在将功能性二维码转化为美观的艺术作品。项目使用Rust语言结合qrcode、image和clap等库，实现了多种像素样式（方形、圆形、圆角矩形）、彩色支持和彩虹效果。具体功能包括基础二维码生成、自定义像素样式、智能颜色生成算法和彩虹效果渲染。文章展示了不同风格的生成示例，并强调了艺术化设计时需注意对比度、清晰度等原则。该项目不仅提升了二维码的美观性，也展示了Rust在图像处理中的应用，为常见技术增添了创意元素。
Rust vs Go: 特点与应用场景分析
专注于Python编程技术的分享与交流，致力于帮助开发者提升编程技能，解决实际问题，探索Python的无限可能。
07-10 2546
Rust和Go（Golang）是现代编程语言中两个非常流行的选择。凭借各自的独特优势和广泛的应用场景，吸引了大量开发者的关注。本文将详细介绍Rust和Go的特点，并探讨它们各自适合的应用领域。Rust和Go各自具备独特的特点和优势。Rust以其内存安全性、高性能和并发支持，适合系统编程和高性能应用；而Go则以其简洁性、内置并发性和快速编译，广泛应用于网络服务、分布式系统和云计算领域。根据具体的项目需求和开发目标，选择合适的编程语言能够显著提高开发效率和项目质量。
Rust Web开发框架对比：Warp与Actix-web
Dontla的博客
09-14 2585
Warp是一个基于异步编程的轻量级Web框架，构建在高性能的异步运行时Tokio之上。Warp的核心理念是Filter（过滤器），通过组合不同的过滤器来构建Web应用。主要特点类型安全且可组合的过滤器系统内置WebSocket支持友好的错误处理机制简洁的API设计Actix-web是一个功能丰富、高性能的Web框架，同样基于Tokio运行时。它采用了Actor模型，擅长处理高并发和复杂的异步操作。主要特点基于Actor模型的并发处理丰富的中间件支持强大的生态系统优异的性能表现。
rust-vnc:VNC协议，客户端状态机，客户端和代理的实现
05-09
vnc是一个实现VNC协议和客户端状态机的工具箱。 也有两个板条箱在使用它： 一个基于SDL2的功能齐全的VNC客户端， vnc-client ； 缓冲的VNC代理vnc-proxy 。 VNC客户端具有特殊的技巧，可以解决QEMU（和Xen HVM）...
Rust异步状态机解析：手写Future实现底层运行时.pdf
05-03
文档内所有文字、图表、函数、目录等元素均显示正常，无任何异常情况，敬请您放心查阅与使用。文档仅供学习参考，请勿用作商业用途。 Rust 以内存安全、零成本抽象和并发高效的特性，重塑编程体验。无需垃圾回收，却...
rust-fsm:具有可读规范的Rust有限状态机框架
05-09
过渡功能-一种根据状态机的当前状态和提供的输入来更改状态机状态的功能。 输出功能-根据当前状态和提供的输入从输出字母中输出内容的功能。 机器的初始状态。 请注意，在实现级别，这种抽象允许构建任何类型的...
Rust系统编程实战：驾驭内存安全、无畏并发与WASM跨平台开发.pdf
08-23
内容概要：本文深入探讨Rust在系统编程领域的核心实战应用，包括内存安全、并发编程以及WebAssembly（WASM）跨平台开发。文章详细介绍了Rust如何通过所有权机制保障内存安全，避免数据竞态问题；如何利用 fearless ...
Rust 练习册 63：循环缓冲区与数据结构实现
少湖说
11-20 646
本文介绍了循环缓冲区（Circular Buffer）的实现方法，这是一种固定大小的先进先出数据结构。文章详细讲解了其核心特性：固定内存占用、O(1)时间复杂度的读写操作，以及避免频繁内存分配的优势。通过Rust代码示例展示了如何实现循环缓冲区的基本功能，包括初始化、写入、读取、清空和覆盖操作。实现使用了Vec<Option<T>>存储元素，并通过索引追踪读写位置，当缓冲区满时会覆盖最旧数据。该数据结构在需要高效内存管理和连续数据处理的场景中非常实用。
RustFS：大模型时代的数据基石——千卡训练集群的存储解决方案
分布式存储与RustFS的博客
11-20 1089
2025年AI大模型训练面临存储瓶颈问题，RustFS存储系统成为关键解决方案。该系统通过内存安全设计、元数据分离架构和智能数据分片技术，在千卡GPU集群中实现4K随机读1,580KIOPS（比MinIO快42%），显著提升训练效率。RustFS的优化包括检查点存储、数据预热策略、RDMA网络支持和多级缓存体系，使GPU利用率从55%提升至92%，训练时间缩短30%。该系统兼容S3协议，支持Kubernetes部署，提供完整的监控运维体系，并计划进一步实现存储感知训练优化，成为大模型时代的关键基础设施。
Rust 练习册 56：阿姆斯特朗数与数学算法探索
少湖说
11-20 1499
本文介绍了阿姆斯特朗数的概念及其在Rust中的实现方法。阿姆斯特朗数是指一个n位数，其各位数字的n次幂之和等于该数本身。文章分析了两种主要实现方式：基于字符串转换的简洁实现和纯数学运算方法，并比较了它们的性能特点。此外，还探讨了边界情况处理、函数式编程风格的应用以及阿姆斯特朗数的数学特性。这种数字在算法教学中常作为典型例子，用于练习循环和数学运算。
Rust高性能Web后端服务开发与Actix-Web实战分享：零成本抽象、高并发处理与内存安全实践
最新发布
2501_94181083的博客
11-23 594
数据序列化使用bincode替代 JSON：节省 30% CPU对热点代码进行#[inline]展开Netty 式 Reactor 模型减少线程调度开销批量 DB 提交减少 IO 压力缓存热点业务路径到 Redis最终整个平台达成：单机 QPS：18 万P99 延迟 < 30msCPU 占用在可控范围内资源释放完全可预期，无内存泄漏风险高性能，无 GC 停顿编译期保证内存安全，避免线上事故Actix-Web 性能强劲，适合高并发系统适合对性能和稳定性要求极高的互联网生产环境。
使用chirp内网穿透工具联合rustdesk 实现远程操作安卓手机
a942242856的博客
11-21 571
本文介绍如何利用Chirp内网穿透工具配合RustDesk实现远程控制安卓手机。首先需要下载RustDesk安卓版和Chirp安卓版，并进行自启动和后台运行设置。在RustDesk中开启IP直连功能并启动服务，然后在Chirp中添加隧道映射，将RustDesk的内网IP和端口映射到远程端口。最后通过电脑端RustDesk输入远程IP和端口即可连接手机。文章还提示了可能出现的连接问题及解决方法，强调需要确保两个应用的后台运行权限。该方法无需自建服务器，简单易行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

少湖说

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值