Rust 入門 - rustup でインストールして、コラッツ数列ツールで動作確認する

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

rustc --version    # rustc 1.96.0 (ac68faa20 2026-05-25)
cargo --version    # cargo 1.96.0 (30a34c682 2026-05-25)

rustup update                 # 安定版を最新へ更新
rustup show                   # 現在のツールチェーンを表示
rustup component add clippy   # リンタ clippy を追加
rustup self uninstall         # Rust をまるごとアンインストール

cargo new collatz        # collatz/ に雛形を生成（Cargo.toml と src/main.rs）
cd collatz
cargo run                # ビルドして実行（デバッグビルド）
cargo run -- 27          # -- 以降はプログラムへの引数
cargo test               # テストを実行
cargo build --release    # 最適化付きのリリースビルド
cargo fmt                # コード整形
cargo clippy             # 静的解析（リンタ）

[package]
name = "collatz"
version = "0.1.0"
edition = "2024"
 
[dependencies]

/// コラッツ数列の計算結果。
struct Collatz {
    start: u64,
    sequence: Vec<u64>,
    /// 数列の最大値（途中でどこまで大きくなったか）。
    peak: u64,
}
 
impl Collatz {
    /// `start` から 1 までのコラッツ数列を計算する。
    /// オーバーフローした場合は `Err` を返す。
    fn compute(start: u64) -> Result<Self, String> {
        if start == 0 {
            return Err("0 は対象外です（正の整数を入力してください）".to_string());
        }
 
        let mut sequence = vec![start];
        let mut current = start;
 
        while current != 1 {
            current = if current % 2 == 0 {
                current / 2
            } else {
                // 3n + 1。巨大な入力でのオーバーフローを安全に検出する。
                current
                    .checked_mul(3)
                    .and_then(|v| v.checked_add(1))
                    .ok_or_else(|| format!("{start} の計算中に u64 がオーバーフローしました"))?
            };
            sequence.push(current);
        }
 
        let peak = *sequence.iter().max().expect("数列は必ず1要素以上ある");
        Ok(Collatz { start, sequence, peak })
    }
}

fn main() {
    let args: Vec<String> = env::args().skip(1).collect();
 
    if args.is_empty() {
        eprintln!("使い方: cargo run -- <正の整数> [<正の整数> ...]");
        process::exit(2);
    }
 
    let mut had_error = false;
    for arg in &args {
        if let Err(e) = run(arg) {
            eprintln!("エラー: {e}");
            had_error = true;
        }
    }
 
    if had_error {
        process::exit(1);
    }
}

                   6 -> steps:   8, peak: 16
  6 -> 3 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1
                  11 -> steps:  14, peak: 52
  11 -> 34 -> 17 -> 52 -> 26 -> 13 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1
                  27 -> steps: 111, peak: 9232

エラー: 0 は対象外です（正の整数を入力してください）
エラー: 'abc' は正の整数として解釈できません

#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn sequence_for_six() {
        let c = Collatz::compute(6).unwrap();
        assert_eq!(c.sequence, vec![6, 3, 10, 5, 16, 8, 4, 2, 1]);
        assert_eq!(c.steps(), 8);
        assert_eq!(c.peak, 16);
    }
 
    #[test]
    fn classic_twenty_seven() {
        // 27 は 111 ステップ・ピーク 9232 で有名なケース。
        let c = Collatz::compute(27).unwrap();
        assert_eq!(c.steps(), 111);
        assert_eq!(c.peak, 9232);
    }
 
    #[test]
    fn zero_is_rejected() {
        assert!(Collatz::compute(0).is_err());
    }
}

running 4 tests
....
test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out