can-you-find-the-best-dungeons-dragons-strategy

results.md

roll	single dice	advantage	disadvantage	advantage of disadvantage	disadvantage of advantage
n = 1	1	1	1	1	1
n = 2	0.95	0.9975	0.9025	0.99500626	0.9904938
n = 3	0.9	0.99	0.81	0.9801	0.9639
n = 4	0.85	0.9775	0.7225	0.95550627	0.9229938
n = 5	0.8	0.96	0.64	0.9216	0.8704
n = 6	0.75	0.9375	0.5625	0.87890625	0.80859375
n = 7	0.7	0.91	0.49	0.8281	0.7399
n = 8	0.65	0.8775	0.4225	0.77000624	0.6664938
n = 9	0.6	0.84	0.36	0.7056	0.5904
n = 10	0.55	0.7975	0.3025	0.63600624	0.5134938
n = 11	0.5	0.75	0.25	0.5625	0.4375
n = 12	0.45	0.6975	0.2025	0.48650625	0.36399376
n = 13	0.4	0.64	0.16	0.4096	0.2944
n = 14	0.35	0.5775	0.1225	0.33350626	0.22999375
n = 15	0.3	0.51	0.09	0.2601	0.1719
n = 16	0.25	0.4375	0.0625	0.19140625	0.12109375
n = 17	0.2	0.36	0.04	0.1296	0.0784
n = 18	0.15	0.2775	0.0225	0.07700625	0.04449375
n = 19	0.1	0.19	0.01	0.0361	0.0199
n = 20	0.05	0.0975	0.0025	0.00950625	0.00499375
average	10.5	13.825	7.175	11.166662	9.833338

source.rs

fn main() {
    println!("| roll    | single dice | advantage | disadvantage | advantage of disadvantage | disadvantage of advantage |");
    println!("| ------- | ----------- | --------- | ------------ | ------------------------- | ------------------------- |");
    for n in 1..=20 {
        println!(
            "| n = {:<3} | {:<11} | {:<9} | {:<12} | {:<25} | {:<25} |",
            n,
            for_given_n::single_dice(n),
            for_given_n::advantage(n),
            for_given_n::disadvantage(n),
            for_given_n::advantage_of_disadvantage(n),
            for_given_n::disadvantage_of_advantage(n),
        );
    }
    println!(
        "| {:<7} | {:<11} | {:<9} | {:<12} | {:<25} | {:<25} |",
        "average",
        average_roll::single_dice(),
        average_roll::advantage(),
        average_roll::disadvantage(),
        average_roll::advantage_of_disadvantage(),
        average_roll::disadvantage_of_advantage(),
    );
}

mod average_roll {
    use itertools::Itertools;

    pub fn single_dice() -> f32 {
        (1..=20).sum::<usize>() as f32 / 20_f32
    }

    pub fn disadvantage() -> f32 {
        (1..=20)
            .cartesian_product(1..=20)
            .map(|(roll1, roll2)| roll1.min(roll2))
            .sum::<usize>() as f32
            / 400_f32
    }

    pub fn advantage() -> f32 {
        (1..=20)
            .cartesian_product(1..=20)
            .map(|(roll1, roll2)| roll1.max(roll2))
            .sum::<usize>() as f32
            / 400_f32
    }

    pub fn advantage_of_disadvantage() -> f32 {
        (1..=20)
            .cartesian_product(1..=20)
            .cartesian_product((1..=20).cartesian_product(1..=20))
            .map(|((roll1, roll2), (roll3, roll4))| roll1.max(roll2).min(roll3.max(roll4)))
            .sum::<usize>() as f32
            / 160_000_f32
    }

    pub fn disadvantage_of_advantage() -> f32 {
        (1..=20)
            .cartesian_product(1..=20)
            .cartesian_product((1..=20).cartesian_product(1..=20))
            .map(|((roll1, roll2), (roll3, roll4))| roll1.min(roll2).max(roll3.min(roll4)))
            .sum::<usize>() as f32
            / 160_000_f32
    }
}

mod for_given_n {
    use itertools::Itertools;

    // percent out of 100
    pub fn single_dice(n: usize) -> f32 {
        assert!(n <= 20);
        // really this is just (21 - n) * 0.05
        (1..=20).filter(|&roll| roll >= n).count() as f32 / 20_f32
    }

    pub fn disadvantage(n: usize) -> f32 {
        assert!(n <= 20);
        (1..=20)
            .cartesian_product(1..=20)
            .filter(|&(roll1, roll2)| roll1.min(roll2) >= n)
            .count() as f32
            / 400_f32
    }

    pub fn advantage(n: usize) -> f32 {
        assert!(n <= 20);
        (1..=20)
            .cartesian_product(1..=20)
            .filter(|&(roll1, roll2)| roll1.max(roll2) >= n)
            .count() as f32
            / 400_f32
    }

    pub fn advantage_of_disadvantage(n: usize) -> f32 {
        assert!(n <= 20);
        (1..=20)
            .cartesian_product(1..=20)
            .cartesian_product((1..=20).cartesian_product(1..=20))
            .filter(|&((roll1, roll2), (roll3, roll4))| roll1.max(roll2).min(roll3.max(roll4)) >= n)
            .count() as f32
            / 160_000_f32
    }

    pub fn disadvantage_of_advantage(n: usize) -> f32 {
        assert!(n <= 20);
        (1..=20)
            .cartesian_product(1..=20)
            .cartesian_product((1..=20).cartesian_product(1..=20))
            .filter(|&((roll1, roll2), (roll3, roll4))| roll1.min(roll2).max(roll3.min(roll4)) >= n)
            .count() as f32
            / 160_000_f32
    }
}