Skip to main content

hyprstream_bench/gen/
arith.rs

1//! Arithmetic word problems. Truth is computed in `i64`; distractors and
2//! near-miss claims are the classic slips (±1, off-by-ten, transposed digits,
3//! add/subtract confusion).
4
5use hyprstream_decision::Entry;
6
7use crate::family::{Family, Stratum};
8use crate::gen::stream;
9use crate::item::Item;
10
11const FAMILY: Family = Family::Arith;
12
13struct Problem {
14    text: String,
15    answer: i64,
16}
17
18fn problem(seed: u64) -> Problem {
19    let mut rng = stream(seed);
20    let subject = ["apples", "bolts", "tickets", "bricks", "litres"][rng.below(5) as usize];
21    let start = rng.range(3, 97);
22    let added = rng.range(2, 88);
23    let removed = rng.range(1, added + start - 1);
24    let answer = start + added - removed;
25    let text = format!(
26        "A crate holds {start} {subject}. {added} more are delivered, then {removed} are shipped out."
27    );
28    Problem { text, answer }
29}
30
31fn transpose_slip(value: i64) -> i64 {
32    let text = value.to_string();
33    // Load-bearing edge case: a palindrome-ish value (e.g. 22) transposes to
34    // itself, so this can return the answer unchanged. Both call sites rely
35    // on that: noul checks `slip == answer`, choice's `retain` drops it.
36    if text.len() >= 2 {
37        let mut chars: Vec<char> = text.chars().collect();
38        let n = chars.len();
39        chars.swap(n - 2, n - 1);
40        chars
41            .into_iter()
42            .collect::<String>()
43            .parse()
44            .unwrap_or(value)
45    } else {
46        value + 10
47    }
48}
49
50pub fn noul(seed: u64, stratum: Stratum) -> Item {
51    let mut rng = stream(seed ^ 0xA0);
52    let problem = problem(seed);
53    let (claim, truth) = match stratum {
54        Stratum::NearMiss => {
55            // Near-miss arithmetic: the claim is one slip away from correct
56            // half the time, so the stratum mixes true and false at the
57            // hardest margin.
58            let slip = [
59                problem.answer + 1,
60                problem.answer - 1,
61                transpose_slip(problem.answer),
62            ][rng.below(3) as usize];
63            if rng.below(2) == 0 {
64                (slip, slip == problem.answer)
65            } else {
66                (problem.answer, true)
67            }
68        }
69        _ => {
70            let offset = rng.range(-3, 3);
71            (problem.answer + offset, offset == 0)
72        }
73    };
74    Item::noul(
75        FAMILY,
76        stratum,
77        seed,
78        Entry::Str(problem.text),
79        format!("Is the final count exactly {claim}?"),
80        truth,
81    )
82}
83
84pub fn choice(seed: u64, stratum: Stratum) -> Item {
85    let mut rng = stream(seed ^ 0xC0);
86    let problem = problem(seed);
87    let mut distractors: Vec<i64> = match stratum {
88        Stratum::NearMiss => vec![
89            problem.answer + 1,
90            problem.answer - 1,
91            transpose_slip(problem.answer),
92            problem.answer + 10,
93        ],
94        _ => vec![
95            problem.answer + rng.range(2, 5),
96            problem.answer - rng.range(2, 5),
97            problem.answer + rng.range(6, 12),
98            problem.answer + rng.range(13, 25),
99        ],
100    };
101    distractors.retain(|d| *d != problem.answer && *d >= 0);
102    distractors.dedup();
103    let count = 3 + rng.below(2) as usize; // 3–4 options
104    distractors.truncate(count - 1);
105    let mut values = distractors;
106    let correct = rng.below(values.len() as u64 + 1) as usize;
107    values.insert(correct, problem.answer);
108    Item::choice(
109        FAMILY,
110        stratum,
111        seed,
112        Entry::Str(problem.text),
113        "What is the final count?",
114        values.iter().map(ToString::to_string).collect(),
115        correct,
116    )
117}
118
119/// Magnitude buckets: 0–9, 10–49, 50–99, 100+.
120fn bucket(value: i64) -> usize {
121    match value {
122        v if v < 10 => 0,
123        v if v < 50 => 1,
124        v if v < 100 => 2,
125        _ => 3,
126    }
127}
128
129pub fn score(seed: u64, stratum: Stratum) -> Item {
130    let problem = problem(seed);
131    Item::score(
132        FAMILY,
133        stratum,
134        seed,
135        Entry::Str(problem.text),
136        "How large is the final count? Levels: 0 = under 10, 1 = 10–49, 2 = 50–99, 3 = 100 or more.",
137        4,
138        bucket(problem.answer),
139    )
140}