I usually write Python code, but Pascal was my first programming language - almost two decades ago now - and I have been using it a bit lately to solve some DMOJ problems. It's a decent fit for a lot of them, and it produces ridiculously lean programs to boot.

The bonuses, though, will have to wait. Unless reverse polish notation is acceptable?

Pascal (fpc 3.0.0)

program DiceRoller;
{$mode objfpc}
uses
  SysUtils, RegExpr;
var
  line : String;

function DiceRoll(spec : String; show : Boolean = False) : Integer;
var
  dice, faces, roll, i : Integer;
  re : TRegExpr;
begin
  re := TRegExpr.Create('(\d*)\s*d\s*(\d+)\s*(([+-])\s*(\d+))?');
  if re.Exec(spec) then
  begin
    if Length(re.Match[1]) > 0 then
      dice := StrToInt(re.Match[1])
    else
      dice := 1;
    faces := StrToInt(re.Match[2]);
    if re.Match[4] = '+' then DiceRoll := + StrToInt(re.Match[5]);
    if re.Match[4] = '-' then DiceRoll := - StrToInt(re.Match[5]);
    for i := 1 to dice do
    begin
      roll := Random(faces) + 1;
      DiceRoll := DiceRoll + roll;
      if show then Write(roll, ' ');
    end;
  end;
  if show then WriteLn;
  re.Free;
end;

begin
  Randomize;
  repeat
    ReadLn(line);
    WriteLn(DiceRoll(line, True));
  until line = '';
end.

Python 3.x

import re, sys, random, operator as op

def dice_roll(spec, show=False):
    match = re.match(r"(\d*)d(\d+)(([+-])(\d+))?", spec)
    dice = int(match.group(1) or "1")
    faces = int(match.group(2))
    adds = [1, -1][match.group(4) == "-"] * int(match.group(5)) if match.group(3) else 0
    rolls = [random.randint(1, faces) for i in range(dice)]
    if show:
        print(" ".join(map(str, rolls)))
    return sum(rolls) + adds

def rpn(line):
    operators = {"+": op.add, "-": op.sub, "*": op.mul, "/": op.truediv}
    stack = []
    for token in line.split():
        if "d" in token:
            stack.append(dice_roll(token))
        elif token in operators:
            b, a = stack.pop(-1), stack.pop(-1)
            stack.append(operators[token](a, b))
        else:
            try:
                stack.append(int(token))
            except ValueError:
                pass
    return(stack[-1])

if __name__ == "__main__":
    for line in sys.stdin:
        print(rpn(line.strip()))

Edit: s/dices/dice/g, s|(\d*)d(\d+)(([+-])(\d+))?|(\d*)\s*d\s*(\d+)\s*(([+-])\s*(\d+))?|

This one was really fun to implement and a good reminder that I know how to do a tiny subset of things in C++ very well and many, many things very badly.

Does 2.5/3 bonuses (takes expressions in polish notation)
C++

#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int roll(int n) {
	return ((rng()%n)+n)%n+1;
}
bool isOp(char c) {
	return (c == '+') || (c=='-') || (c=='*') || (c=='/');
}
vvi gentree(vector<string>& vs) {
	stack<int> st;
	vvi g;
	g.assign(vs.size(),vi());
	if(isOp(vs[0][0])) {st.push(0);st.push(0);}
	for(int i=1;i<vs.size();i++) {
		if(st.empty()) {return vvi();}
		int id = st.top();st.pop();
		if(isOp(vs[i][0])) {
			st.push(i);
			st.push(i);
		}
		g[id].push_back(i);
	}
	if(!st.empty()) {return vvi();}
	return g;
}
int parseDice(string& s) {
	int val = 0;
	int pos = -1;
	bool dc = false;
	for(int i=0;i<s.size();i++) {
		if(s[i] == 'd') {
			dc = true;
			pos = i;
			break;
		}
		val *= 10;
		val += s[i]-'0';
	}
	if(dc) {
		val = max(val,1);
		int num = 0;
		int tot = 0;
		for(int i=pos+1;i<s.size();i++) {
			num *= 10;
			num += s[i]-'0';
		}
		for(int i=0;i<val;i++) {
			int r = roll(num);
			tot += r;
			cout << "d" << num << ": " << r << '\n';
		}
		return tot;
	} else {
		return val;
	}
}
int eval(vvi& tr,vector<string>& vs, int u) {
	if(tr[u].size() > 0) {
		int lf = eval(tr,vs,tr[u][0]);
		int rt = eval(tr,vs,tr[u][1]);
		switch(vs[u][0]) {
			case '+':
				return lf+rt;
			case '-':
				return lf-rt;
			case '*':
				return lf*rt;
			case '/':
				return lf/rt;
			default:
				return -1;
		}
	} else {
		return parseDice(vs[u]);
	}
}
int main() {
	while(1) {
		string st;
		vector<string> vs;
		getline(cin,st);
		stringstream ss(st);
		string t;
		while(getline(ss,t,' ')) {vs.push_back(t);}
		if(vs.size() == 0) break;
		vvi tr = gentree(vs);
		if(tr.size() == 0) {
			printf("Invalid dice expression\n");
			continue;
		}
		int res = eval(tr,vs,0);
		cout << "Result: " << res << '\n';
	}
}

I know this isn't in keeping with the spirit of a challenge, but like @onyxleopard, I'd like to share one of these I wrote several years ago, in Python 2.7. It was part of an RPG project which never took off, but this feels like a good chance to dust it off and set it free, for whatever it's worth.

It satisfies the main criteria and the 3 bonuses, and can also handle exponentiation and implied multiplication with parentheses, like 2d4(3d2+9)^2. It will even work with eldritch dice expressions in which the number of dice, the number of sides the dice have, and the exponent are themselves determined by dice rolls: (2d4)d((3d20)^2d20).

Finally, it can output the result as a number, or it can return a dictionary listing the results of each individual roll, and how the dice expression was tokenized:

> python roll.py -v "2d20 + 1d6 + 3d10"
{'diceRolls': [{'rolls': [11, 1], 'sides': 20, 'sum': 12},
               {'rolls': [5], 'sides': 6, 'sum': 5},
               {'rolls': [2, 6, 6], 'sides': 10, 'sum': 14}],
 'error': False,
 'errorCode': False,
 'origString': '2d20 + 1d6 + 3d10',
 'result': 31,
 'tokenized': [{'tokType': 'number', 'value': 2},
               {'thisRoll': {'rolls': [11, 1], 'sides': 20, 'sum': 12},
                'tokType': 'operator',
                'value': 'd'},
               {'rollResult': {'rolls': [11, 1], 'sides': 20, 'sum': 12},
                'tokType': 'number',
                'value': 20},
               {'tokType': 'operator', 'value': '+'},
               {'tokType': 'number', 'value': 1},
               {'thisRoll': {'rolls': [5], 'sides': 6, 'sum': 5},
                'tokType': 'operator',
                'value': 'd'},
               {'rollResult': {'rolls': [5], 'sides': 6, 'sum': 5},
                'tokType': 'number',
                'value': 6},
               {'tokType': 'operator', 'value': '+'},
               {'tokType': 'number', 'value': 3},
               {'thisRoll': {'rolls': [2, 6, 6], 'sides': 10, 'sum': 14},
                'tokType': 'operator',
                'value': 'd'},
               {'rollResult': {'rolls': [2, 6, 6], 'sides': 10, 'sum': 14},
                'tokType': 'number',
                'value': 10}]}

The original idea was that this structure could be used by other libraries, or marshaled to JSON. The code theoretically uses a Top down operator precedence parser or Pratt parser, but I wasn't a CS major, so it probably shouldn't be used as an exemplar of the form. All the same, I hope this code might be useful to someone, or at least entertaining.

Extremely fun challenge! This is actually a lot like making a very simple compiler, which is always very fun. I will take a look at completing it tonight :)

This is a Python3 dice rolling simulator (I wrote a few years ago).

#!/usr/bin/env python3
"""Roll N M-sided dice from the command line.
    
        N: number of dice to roll (implicitly N=1 if omitted)
        M: the maximum value on the die (must be at least 1)
     e.g.:   'd6' -> roll one six-sided die
           '3d20' -> roll three twenty-sided dice
       'd2 d3 d4' -> roll a two-, three-, and four-sided die
"""

import random
import sys

from argparse import ArgumentError

def die(value):
    """Parse a die string of the form (N)dM int a tuple of integers where:
        N: an optional number of dice (implicitly N=1 if omitted)
        M: the number of sides on the die
    
    E.g.:
        die('d6') -> (1, 6)
        die('1d6') -> (1, 6)
        die('2d4') -> (2, 4)
    """
    try:
        n, m = value.lower().split('d', 1)
        return int(n or 1), int(m)
    except:
        raise ArgumentError('invalid die string')

def roll(n, m):
    """Generate n random integers in the range [1..m]"""
    for i in range(n):
        yield random.randint(1, m)

if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
        description=__doc__
    )
    parser.add_argument(
        'dice',
        nargs='+',
        type=die,
        metavar='[N]dM',
        help='Roll N M-sided dice',
    )
    args = parser.parse_args()
    for n, m in args.dice:
        print('{}d{}\t{}'.format(n, m, sum(roll(n, m))))

$ ./rolldice -h
usage: rolldice [-h] [N]dM [[N]dM ...]

Roll N M-sided dice from the command line. N: number of dice to roll
(implicitly N=1 if omitted) M: the maximum value on the die (must be at least
1) e.g.: 'd6' -> roll one six-sided die '3d20' -> roll three twenty-sided dice
'd2 d3 d4' -> roll a two-, three-, and four-sided die

positional arguments:
  [N]dM       Roll N M-sided dice

optional arguments:
  -h, --help  show this help message and exit
$ ./rolldice d6
1d6	5
$ ./rolldice 3d6
3d6	11
$ ./rolldice {1..6}d6
1d6	3
2d6	10
3d6	10
4d6	10
5d6	14
6d6	26
$ ./rolldice {1..3}d{1..6}
1d1	1
1d2	2
1d3	2
1d4	1
1d5	3
1d6	4
2d1	2
2d2	4
2d3	4
2d4	5
2d5	6
2d6	12
3d1	3
3d2	6
3d3	5
3d4	9
3d5	6
3d6	13
# oh, and for modifiers
./rolldice {1..3}d{1..6} | awk '{print $1 "     " $2 +3}'
1d1	4
1d2	4
1d3	5
1d4	5
1d5	8
1d6	9
2d1	5
2d2	7
2d3	7
2d4	8
2d5	9
2d6	11
3d1	6
3d2	6
3d3	9
3d4	14
3d5	14
3d6	14
$ ./rolldice {1..3}d{1..6} | awk '{print $1 "     " $2 -6}'
1d1	-5
1d2	-5
1d3	-4
1d4	-4
1d5	-3
1d6	-1
2d1	-4
2d2	-3
2d3	-1
2d4	-1
2d5	1
2d6	-1
3d1	-3
3d2	-1
3d3	0
3d4	-1
3d5	5
3d6	7
# oh and you need to sum everything? https://www.gnu.org/software/datamash/
$ ./rolldice {1..3}d{1..6} | awk '{print $1 "     " $2 -6}' | datamash sum 2
-37
# oh you’re Mr. fancy-pants?
./rolldice {1..3}d{1..6} | awk '{print $1 "     " $2 -6}' | datamash --header-out min 2 max 2 mean 2 sstdev 2 sum 2 | csvlook -It
| min(field-2) | max(field-2) | mean(field-2) | sstdev(field-2) | sum(field-2) |
| ------------ | ------------ | ------------- | --------------- | ------------ |
| -5           | 4            | -1.5          | 2.8952293417235 | -27          |

I can't code.. but I'm alright with Sheets. I didn't know what 2d20 - 5 meant, but a friend said its 2x 20 sided dice minus 5 -- so I went with that.

=QUERY(
 TRANSPOSE(
  ARRAYFORMULA(
   RANDBETWEEN(
    ARRAYFORMULA(ROW(A2:A3)-ROW(A1:A2)),20))),
 "select Col1+0, Col2+0, Col1+Col2-5 
 label Col1+0 'Die 1', Col2+0 'Die 2', Col1+Col2-5 'Result'")

edit: this is overkill

=QUERY({RANDBETWEEN(1,20),RANDBETWEEN(1,20)},
 "select Col1+0, Col2+0, Col1+Col2-5 
 label Col1+0 'Die 1', Col2+0 'Die 2', Col1+Col2-5 'Result'")

These solutions seem very nice and well-written, but they're all enormous: the smallest of the two Python versions is almost an entire kilobyte, without even implementing parentheses in the input.

The problem here is trying to figure out the parsing. That seems like too much work for my style of approaching these challenges, so I'll just avoid doing it entirely:

import re
from random import randint as ri
i=int;z=[]
def f(x):z.append([ri(1,i(x[2])+1)for _ in range(0,i(max('1',x[1])))]);return str(sum(z[-1]))
print(eval(re.sub(r"(\d*)d(\d+)",f,input())),z)

By avoiding every challenging part of this challenge, this code is only 196 bytes. It accepts as input any valid Python expression, where XdY can replace numbers, and will return first the final value, then all the rolls involved.

Thus:

• d6+3 ==> 21 [[7]]
• 4d6 * (5d4 - 3) ==> 312 [[5, 7, 7, 7], [2, 3, 5, 3, 2]]
• 4d6**2d4 ==> 7776 [[2, 2, 1, 1], [4, 1]]
• 4d8 > 15 ==> True [[7, 4, 9, 1]]

Obviously, this allows arbitrary code execution. But in this case, that's arguably a feature. For example:

• __import__("math").exp(-(5d8+3))
• __import__("numpy").average([3d7,8d8])
• ["Failure","Success"][4d8 > 15]
• (Disclaimer: don't run this one. Adapted from these redditors.) (__import__("time").sleep(4d8),[o.fork() for (o,i) in [(__import__('os'), __import__('itertools'))] for x in i.count()])

There are two known issues:

• Zero should never be the leading digit in X for XdY (0d5 and 05d5 will act as 1d5).
• XdY handling is done as preprocessing. Thus, eg, sum(4d8 for _ in range(0,1000)) will not roll 4000 d8s. This could be handled, but the challenge would be to keep track of each roll.

Woo that was a trip. Never done anything like this before, so this a pretty horrific and fragile way to handle it.

I started out with the idea of using a tree to represent the math-y witchcraft, which seemed like a good idea at the time. Had a super hard time actually turning a string into a tree structure though.

First attempt worked pretty okay, but didn't implement any order of operations. So 2d5+5 was fine but 5 + 2d5 was run as (5+2)d5. Figured that out after I fed it 2d5000000 + 5d5. It just kept spitting out dice rolls lol.

Second version creates an "unfinished" flat list of tokens then uses a new per-operator Priority to gradually fold it into a tree. Then once the tree is made you ask the root node for its value and the request cascades down the tree until a result appears.

Output:

$ ./dice2 "2d8+2"
Rolling 2d8: ( 2 4 )
Adding 6 and 2...
And your total is 8.

$ ./dice2 "5+5d5+5*5+5d5"
Rolling 5d5: ( 1 1 5 1 2 )
Adding 5 and 10...
Multiplying 5 and 5...Adding 15 and 25...
Rolling 5d5: ( 3 5 1 3 4 )
Adding 40 and 16...
And your total is 56.

package main

import (
	"fmt"
	"math/rand"
	"os"
	"time"
)

func main() {
	rand.Seed(time.Now().UnixNano())
	
	if len(os.Args) < 2 {
		usage()
		return
	}

	var input string
	for i := 1; i < len(os.Args); i++ {
		input += os.Args[i]
	}

	defer func() {
		if r := recover(); r != nil {
			fmt.Println(r)
			usage()
		}
	}()

	parser := Parser{}
	value := parser.Parse(input).GetValue()
	fmt.Printf("And your total is %v.\n", value)
}

var Operations = map[rune]func(int, int) int{
	'd': DiceRollOp,
	'+': AdditionOp,
	'-': SubtractionOp,
	'*': MultiplicationOp,
	'/': DivisionOp,
}

var Priorities = map[rune]int{
	'd': 2,
	'+': 0,
	'-': 0,
	'*': 1,
	'/': 1,
}

func usage() {
	fmt.Println("Usage: dice <expression>")
	fmt.Println("Expressions are made up of alternating numbers and operators.")
	fmt.Println()
	fmt.Println("Supported operators are 'd', '+', and '-'.")
	fmt.Println("XdY rolls a die with Y sides X times.")
	fmt.Println("I'll leave it up to you to guess what + and - do.")
}

type Parser struct{}

func (p *Parser) Parse(input string) MathThing {
	var tokens TokenString
	var currentNum int
	for _, char := range input {
		if char >= '0' && char <= '9' {
			currentNum *= 10
			currentNum += int(char - '0')
			continue
		}

		tokens = append(tokens, Number{currentNum})
		currentNum = 0

		switch char {
		case ' ':
			continue

		case 'd', '+', '-', '*', '/':
			tokens = append(tokens, Operation{Op: Operations[char], Priority: Priorities[char]})

		default:
			panic(fmt.Sprintf("Unknown character %c", char))
		}
	}

	tokens = append(tokens, Number{currentNum})

	for i := tokens.GetNext(); i >= 0; i = tokens.GetNext() {
		left := tokens[i-1]
		right := tokens[i+1]

		if !left.IsComplete() || !right.IsComplete() {
			panic("Syntax error. Somewhere. Good luck. If it helps, looks like there's too many operators and not enough numbers. Could be some weird order of operations crap idk.")
		}

		this := tokens[i].Complete(left, right)

		tokens = append(tokens[:i], tokens[i+2:]...) // Consume 2 tokens.
		tokens[i-1] = this                           // Replace the third token with our new one.
	}

	if len(tokens) != 1 {
		panic("There's some left over bits. Or not enough left over bits. Good luck.")
	}

	return tokens[0]
}

type TokenString []MathThing

func (t TokenString) GetNext() int {
	highestToken := -1
	highestPriority := -1

	for i, token := range t {
		if !token.IsComplete() && token.GetPriority() > highestPriority {
			highestToken = i
			highestPriority = token.GetPriority()
		}
	}

	return highestToken
}

// Is a thing that has a value.
type MathThing interface {
	GetValue() int
	IsComplete() bool
	Complete(MathThing, MathThing) MathThing
	GetPriority() int
}



// Number is just a constant value.
type Number struct {
	Value int
}

func (n Number) GetValue() int {
	return n.Value
}

func (n Number) IsComplete() bool {
	return true
}

func (n Number) Complete(_, _ MathThing) MathThing {
	return n
}

func (n Number) GetPriority() int {
	return -1
}



// OpFunc is a function that does some math magic to 2 values.
type OpFunc func(int, int) int

// Operation has a value that depends on 2 other values and some unspecified black magic.
type Operation struct {
	Left     MathThing
	Right    MathThing
	Op       OpFunc
	Priority int
}

func (o Operation) GetValue() int {
	return o.Op(o.Left.GetValue(), o.Right.GetValue())
}

func (o Operation) IsComplete() bool {
	/*if o.Left == nil || o.Right == nil {
		return false
	}
	return o.Left.IsComplete() && o.Right.IsComplete()*/
	return o.Left != nil && o.Right != nil
}

func (o Operation) Complete(Left, Right MathThing) MathThing {
	o.Left = Left
	o.Right = Right

	return o
}

func (o Operation) GetPriority() int {
	return o.Priority
}



func DiceRollOp(diceCount, diceSize int) int {
	fmt.Printf("Rolling %vd%v: (", diceCount, diceSize)
	var total int
	var roll int
	for i := 0; i < diceCount; i++ {
		roll = rand.Intn(diceSize) + 1
		total += roll
		fmt.Printf(" %v", roll)
	}
	fmt.Println(" )")
	return total
}

func AdditionOp(a, b int) int {
	fmt.Printf("Adding %v and %v...\n", a, b)
	return a + b
}

func SubtractionOp(a, b int) int {
	fmt.Printf("Subtracting %v from %v...\n", b, a)
	return a - b
}

func DivisionOp(a, b int) int {
	fmt.Printf("Dividing %v by %v...\n", a, b)
	return a / b
}

func MultiplicationOp(a, b int) int {
	fmt.Printf("Multiplying %v and %v...\n", a, b)
	return a * b
}

I think it'd be really cool to try and print out the finished tree structure but I could not figure out how to pull that off.

I am a little late to this since I was travelling, but I wanted to share something a little different. I present the Quantum Dice Roller. This was written in Python 3.7 using IBM's qiskit platform. In order to generate randomness, this program places a single quantum bit (qubit) into a superposition of 0 and 1 with equal probability, and then measures this state in order to return 0 or 1 with perfectly equal probability. It uses these random 0s and 1s to build a random string of 0s and 1s which is interpreted as a binary number in order to get the desired random result. So, for example, if you are rolling a d4 it will find the number of bits needed to represent "4" and create a string of that length. The only catch here is that sometimes the result will be greater than the number of sides. For example, for a d4 the program will create a bit string of length 3, which in principle could be "111" which is greater than 4. Thus, it checks the final result and tries again until a valid result is obtained.

In principle, this program could be run on one of IBM's actual quantum computers. As it is written, it uses a simulated quantum processor (and thus probably some standard PRNG). However all it would take is changing the specified backend and making an IBM account to change this. I might do so later just for the novelty of it. I'm happy to answer questions if anyone has them

import math
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute, Aer

def parse(string):
    params = [] #will hold relevant data
    if "+" in string:
        dice_info, modifier = string.split("+")
        dice_info = dice_info.strip()
        modifier = int(modifier.strip())
        nrolls = int(dice_info.split("d")[0])
        nsides = int(dice_info.split("d")[1])
        params=[nrolls, nsides, "+", modifier]
    elif "-" in string:
        dice_info, modifier = string.split("-")
        dice_info = dice_info.strip()
        modifier = int(modifier.strip())
        nrolls = int(dice_info.split("d")[0])
        nsides = int(dice_info.split("d")[1])
        params=[nrolls, nsides, "-", modifier]
    else:
        nrolls = int(string.split("d")[0])
        nsides = int(string.split("d")[1])
        params=[nrolls, nsides]

    return params

def quantum_roll(nbits, nsides):

    max_flag = True
    
    while(max_flag):
        my_backend = Aer.get_backend("qasm_simulator")
        bit_string = ''
        for i in range(nbits):
            q = QuantumRegister(1)
            c = ClassicalRegister(1)
            qc = QuantumCircuit(q, c)
            qc.h(q[0])
            qc.measure(q, c)

            job_sim = execute(qc, my_backend, shots=1)
            sim_result = job_sim.result()
            counts = sim_result.get_counts(qc)
            bit = list(counts.keys())[0]

            bit_string += bit
        
        result = int(bit_string, 2) + 1
        if (result<=nsides):
            max_flag=False

    return result 


def main():
    user_in = input("Enter a dice roll in the form _d__ + _ (e.g. 3d4+2): ")

    roll_params = parse(user_in)
    nrolls=roll_params[0]
    nsides=roll_params[1]
    
    #[0] is nrolls, [1] is nsides [2] is modifier if any

    nbits = nsides.bit_length()

    rolls = [] 
    for roll in range(nrolls):
        rolls.append(quantum_roll(nbits, nsides))
        
    total = sum(rolls)

    if len(roll_params) > 2:
        if roll_params[2] == "+":
            total += roll_params[3]
        elif roll_params[2] == "-":
            total -= roll_params[3]
        else:
            print("Invalid modifier, ignoring")

    roll_str = ",".join([str(x) for x in rolls])
    out = "You rolled the quantum dice {0} times, with results of {1}. This gave a total of {2}".format(nrolls, roll_str, total)

    if len(roll_params) > 2:
        out = out+", after a modifier of {} was applied.".format(roll_params[2]+str(roll_params[3]))
    else:
        out = out+"."

    print(out)

if __name__=="__main__":
    main()

Cool. Trying this in Rust. I'm not a super adept programmer, so I'm having a bit of trouble splitting the input string by regular expression. If I gather number of dice, number of sides, and modifiers separately it's a fairly trivial task, but of course that's not in the spirit of the challenge.

Also, does anyone know how to extract the last digit of a number? I'm trying to be clever and print proper ordinal numbers, but what I have right now only works for the first ten digits.

match (i + 1) {
1 => println!("{}st roll: {}", (i + 1), rolls[i]),
2 => println!("{}nd roll: {}", (i + 1), rolls[i]),
3 => println!("{}rd roll: {}", (i + 1), rolls[i]), 
_ => println!("{}th roll: {}", (i + 1), rolls[i]),
}

Also, there's a lot of repetition, so I imagine it can get even more clever.

I'm very much not a programmer, just someone with an interest in coding. Here's my attempt in python, which probably breaks an awful lot of conventions and rules:

import re,random,argparse

parser = argparse.ArgumentParser(description="Roll dice with or without additional operations")
parser.add_argument("to_roll", metavar="to_roll", type=str, help="A string in the format 4d6+1")
args = parser.parse_args()

to_roll = args.to_roll
input = re.match(r'(\d*)d(\d+)(([+-/\*])(\d+))?', to_roll)

if input:
    if input.group(1):
        dice = int(input.group(1))
    else:
        dice = 1
    faces = int(input.group(2))
    if input.group(3):
        mod_op = input.group(4)
        mod_num = int(input.group(5))
else:
    print("Enter calculation in the correct format ""4d6+1""")

def dice_roll():
    roll_result = []
    for d in range(dice):
        roll = random.randint(1,faces)
        roll_result.append(roll)

    roll_total = 0
    for d in roll_result:
        roll_total+=d

    if input.group(3):
        if mod_op == "+":
            roll_total+=mod_num
        if mod_op == "-":
            roll_total+-mod_num
        if mod_op == "/":
            roll_total//=mod_num
        if mod_op == "*":
            roll_total*=mod_num

    print("Rolled:",*roll_result)
    print("Total:",roll_total)

dice_roll()