How do I implement this specialized roll-and-keep mechanic in AnyDice?

Question

I need help with an anydice function.

I'm looking for a modified Roll and Keep type of mechanic, where if you have more dice that roll the max result than you are keeping, each discarded max result adds +1 to the total.

Example: if you were rolling 6d10 and keeping two (equivalent to HIGHEST 2 of 6d10 in anydice), and you rolled 10, 10, 10, 8, 3, and 1, your total would be 21--that's 20 for the two 10s you kept, and +1 for the 10 you couldn't keep.

Example 2: if you were rolling 5d6 drop 2 (equivalent to HIGHEST 3 of 5d6 in anydice), and rolled 6, 6, 6, 6, and 6, your result would be 20.

Maybe I don't know how to word what I am looking for correctly, but I have not been able to find any answers to this question when searching around online.

Thanks in advance.

Answer 1

Here's an implementation of Ben Barden's algorithm to compute the distributions you want.

function: N:n of SIZE:n keep K:n extras add {
    result: [helper NdSIZE SIZE K]
}

function: helper ROLL:s SIZE:n K:n {
    COUNT: [count SIZE in ROLL]
    if COUNT > K { result: K*SIZE - K + COUNT }
    result: {1..K}@ROLL
}

The output is somewhat underwhelming, since your bonus points for having lots of extra maximum values on your dice rarely happens. You need very large die pools relative to the number of dice you're keeping for the rule to have any noticeable effect. Here's some code that computes the distributions for keeping three dice from varying pools of d6s. The effect of the special rule only really matters for pools that are many times larger than the number of dice you're keeping.

D: 6
K: 3

loop N over {K+1..K+8} {
  output [N of D keep K extras add] named "[N]d[D] keep [K] extras add +1"
}
loop N over {K+1..K+8} {
  output {1..K}@NdD named "[N]d[D] keep [K]"
}

Your special rule only effects the small part of the graph over on the right, where the circle-marked lines diverge from the square marked lines out beyond 18 (the normal maximum for 3d6). For values less than 18 (which is 95% or more of the distribution for most of the pool sizes), the two kinds of lines are exactly coincident.

Answer 2

As usual, the answer is to write a function. Something like this, for example:

function: ROLL:s keep N:n plus one for each extra MAX:n {
  SUM: {1..N}@ROLL
  COUNT: ROLL = MAX
  result: SUM + [highest of 0 and COUNT - N]
}

output [highest 2 of 6d10] named "normal"
output [6d10 keep 2 plus one for each extra 10] named "with bonus"

Of course, you could also shorten that to just:

function: ROLL:s keep N:n plus one for each extra MAX:n {
  result: {1..N}@ROLL + [highest of 0 and (ROLL = MAX) - N]
}

but I figured that a few extra named variables wouldn't hurt readability.

---

Note: I've revised my code to produce the same results as Blckknght's solution, since my original interpretation (of giving +1 for every discarded die matching highest number actually rolled, i.e. basically omitting the MAX parameter and setting MAX: 1@ROLL instead) seems to have been based on a misreading of the question. (For anyone who's curious, my original code can be found in the edit history of this answer.) I encourage everyone to upvote Blckknght's excellent answer.

In any case, if the logic I've implemented above is not exactly what you want, you should hopefully be able to edit the code fairly easily to match your actual mechanic. Note that, inside the function, ROLL is just a fixed sequence of numbers (sorted in descending order), so you can use any sequence manipulation syntax in AnyDice on it.

Answer 3

You should be able to handle this with a conditional block, because your dicerolling mechanic really splits into two distinct options. The psuedocode would look something like the following

Roll 5d6

if (# of 6s) > = 3 {
   output 15 + (# of 6s)
}
else {
   output sum of top 3 dice
}
```

Answer 4

The trick may be in exploiting Anydice's type casting in functions. When you cast a variable DICE as sequences (DICE:s), the function gets evaluated for every possible combination of DICE

https://anydice.com/program/23cf1

function: roll DICE:s keeping N:n {

  result: {1..N}@DICE + [highest of 0 and [count [maximum of 1@DICE] in DICE] - N]
}

output [roll 8d6 keeping 5] named "8d6 keeping 5"
output [roll 5d10 keeping 3] named "5d10 keeping 3"