xiangting 5.0.6

A library for calculating the deficiency number (a.k.a. xiàngtīng number, 向聴数).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

// SPDX-FileCopyrightText: 2025 Apricot S.
// SPDX-License-Identifier: MIT
// This file is part of https://github.com/Apricot-S/xiangting

use super::common::YAOJIUPAI_INDICES;
use crate::bingpai::Bingpai;
use crate::tile::TileFlags;

pub(in super::super) fn calculate_necessary_tiles(bingpai: &Bingpai) -> (u8, TileFlags) {
    if bingpai.num_required_bingpai_mianzi() < 4 {
        return (u8::MAX, 0);
    }

    let (num_kinds, has_jiangpai, waits, wait_candidates) = YAOJIUPAI_INDICES
        .iter()
        .map(|&i| (i, &bingpai.tile_counts()[i]))
        .fold(
            (0, false, 0u64, 0u64),
            |(num_kinds, has_jiangpai, waits, wait_candidates), (i, &count)| match count {
                0 => (num_kinds, has_jiangpai, waits | (1 << i), wait_candidates),
                1 => (
                    num_kinds + 1,
                    has_jiangpai,
                    waits,
                    wait_candidates | (1 << i),
                ),
                2..=4 => (num_kinds + 1, true, waits, wait_candidates),
                _ => unreachable!("tile {i} count must be 4 or less but was {count}"),
            },
        );

    let replacement_number = 14 - num_kinds - (has_jiangpai as u8);

    let necessary_tiles = if has_jiangpai {
        waits
    } else {
        waits | wait_candidates
    };

    (replacement_number, necessary_tiles)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test_utils::FromTileCode;
    use crate::tile::{TileCounts, TileFlags};

    #[test]
    fn calculate_necessary_tiles_no_terminals_and_honors() {
        let tile_counts = TileCounts::from_code("23455m345p45678s");
        let bingpai = Bingpai::new(&tile_counts).unwrap();
        let (replacement_number, necessary_tiles) = calculate_necessary_tiles(&bingpai);
        assert_eq!(replacement_number, 14);
        assert_eq!(necessary_tiles, TileFlags::from_code("19m19p19s1234567z"));
    }

    #[test]
    fn calculate_necessary_tiles_without_pair() {
        let tile_counts = TileCounts::from_code("189m12p249s12345z");
        let bingpai = Bingpai::new(&tile_counts).unwrap();
        let (replacement_number, necessary_tiles) = calculate_necessary_tiles(&bingpai);
        assert_eq!(replacement_number, 5);
        assert_eq!(necessary_tiles, TileFlags::from_code("19m19p19s1234567z"));
    }

    #[test]
    fn calculate_necessary_tiles_with_pair() {
        let tile_counts = TileCounts::from_code("119m12p299s12345z");
        let bingpai = Bingpai::new(&tile_counts).unwrap();
        let (replacement_number, necessary_tiles) = calculate_necessary_tiles(&bingpai);
        assert_eq!(replacement_number, 4);
        assert_eq!(necessary_tiles, TileFlags::from_code("9p1s67z"));
    }

    #[test]
    fn calculate_necessary_tiles_tenpai() {
        let tile_counts = TileCounts::from_code("11m19p19s1234567z");
        let bingpai = Bingpai::new(&tile_counts).unwrap();
        let (replacement_number, necessary_tiles) = calculate_necessary_tiles(&bingpai);
        assert_eq!(replacement_number, 1);
        assert_eq!(necessary_tiles, TileFlags::from_code("9m"));
    }

    #[test]
    fn calculate_necessary_tiles_tenpai_13_wait() {
        let tile_counts = TileCounts::from_code("19m19p19s1234567z");
        let bingpai = Bingpai::new(&tile_counts).unwrap();
        let (replacement_number, necessary_tiles) = calculate_necessary_tiles(&bingpai);
        assert_eq!(replacement_number, 1);
        assert_eq!(necessary_tiles, TileFlags::from_code("19m19p19s1234567z"));
    }

    #[test]
    fn calculate_necessary_tiles_win() {
        let tile_counts = TileCounts::from_code("119m19p19s1234567z");
        let bingpai = Bingpai::new(&tile_counts).unwrap();
        let (replacement_number, necessary_tiles) = calculate_necessary_tiles(&bingpai);
        assert_eq!(replacement_number, 0);
        assert_eq!(necessary_tiles, TileFlags::from_code(""));
    }

    #[test]
    fn calculate_necessary_tiles_incomplete_hand() {
        let tile_counts = TileCounts::from_code("19p19s1234567z");
        let bingpai = Bingpai::new(&tile_counts).unwrap();
        let (replacement_number, necessary_tiles) = calculate_necessary_tiles(&bingpai);
        assert_eq!(replacement_number, u8::MAX);
        assert_eq!(necessary_tiles, TileFlags::from_code(""));
    }
}