背景
我定期和一些朋友一起玩D＆D。在谈论某些系统/版本在掷骰子时的复杂性以及应用奖金和罚金时，我们开玩笑地为骰子掷骰表达了一些额外的复杂性。它们中的一些太离谱了（例如扩展简单的dice表达式，例如2d6对参数1进行矩阵化），但是其余的组成了一个有趣的系统。
挑战
给定一个复杂的骰子表达式，请根据以下规则对其进行评估并输出结果。
基本评估规则
- 每当运算符需要整数但收到操作数的列表时，都会使用该列表的总和
- 每当运算符需要一个列表但收到一个操作数的整数时，该整数就被视为包含该整数的单元素列表
经营者
所有运算符都是二进制中缀运算符。为了便于说明，a将为左操作数，b并将为右操作数。列表符号将用于运算符可以将列表作为操作数的示例，但实际表达式仅由正整数和运算符组成。
d：输出a范围内的独立均匀随机整数[1, b]- 优先顺序：3
- 两个操作数都是整数
- 范例：
3d4 => [1, 4, 3]，[1, 2]d6 => [3, 2, 6]
t：取b最低值a- 优先顺序：2
a是列表，b是整数- 如果为
b > len(a)，则返回所有值 - 例如：
[1, 5, 7]t1 => [1]，[5, 18, 3, 9]t2 => [3, 5]，3t5 => [3]
T：从中获取b最高值a- 优先顺序：2
a是列表，b是整数- 如果为
b > len(a)，则返回所有值 - 例如：
[1, 5, 7]T1 => [7]，[5, 18, 3, 9]T2 => [18, 9]，3T5 => [3]
r：如果中有任何元素，b则a使用d生成它们的任何语句重新 滚动这些元素- 优先顺序：2
- 两个操作数都是列表
- 重新滚动仅执行一次，因此
b结果中仍可能包含的元素 - 例如：
3d6r1 => [1, 3, 4] => [6, 3, 4]，2d4r2 => [2, 2] => [3, 2]，3d8r[1,8] => [1, 8, 4] => [2, 2, 4]
R：如果中有任何元素，b则使用生成它们的任何语句a重复滚动这些元素，直到不b存在任何元素d- 优先顺序：2
- 两个操作数都是列表
- 例如：
3d6R1 => [1, 3, 4] => [6, 3, 4]，2d4R2 => [2, 2] => [3, 2] => [3, 1]，3d8R[1,8] => [1, 8, 4] => [2, 2, 4]
+：加a和b在一起- 优先顺序：1
- 两个操作数都是整数
- 例如：
2+2 => 4，[2]+[2] => 4，[3, 1]+2 => 6
-：减去b从a- 优先顺序：1
- 两个操作数都是整数
b永远小于a- 例如：
2-1 => 1，5-[2] => 3，[8, 3]-1 => 10
.：串连a和b在一起- 优先顺序：1
- 两个操作数都是列表
- 例如：
2.2 => [2, 2]，[1].[2] => [1, 2]，3.[4] => [3, 4]
_：输出a已b删除的 所有元素- 优先顺序：1
- 两个操作数都是列表
- 例如：
[3, 4]_[3] => [4]，[2, 3, 3]_3 => [2]，1_2 => [1]
附加规则
- 如果表达式的最终值是列表，则将其求和后再输出
- 项的求值将仅产生正整数或正整数列表-任何导致非正整数或包含至少一个非正整数的列表的表达式都将用
1s 替换那些值 - 括号可用于对术语进行分组并指定评估顺序
- 运算符将按照从最高优先级到最低优先级的顺序进行评估，如果是捆绑优先级，则评估从左到右进行（因此
1d4d4将评估为(1d4)d4） - 列表中元素的顺序无关紧要-修改列表的操作员以不同的相对顺序返回带有元素的列表是完全可以接受的
- 无法评估或可能导致无限循环的字词（如
1d1R1或3d6R[1, 2, 3, 4, 5, 6]）无效
测试用例
格式： input => possible output
1d20 => 13
2d6 => 8
4d6T3 => 11
2d20t1 => 13
5d8r1 => 34
5d6R1 => 20
2d6d6 => 23
3d2R1d2 => 3
(3d2R1)d2 => 11
1d8+3 => 10
1d8-3 => 4
1d6-1d2 => 2
2d6.2d6 => 12
3d6_1 => 8
1d((8d20t4T2)d(6d6R1r6)-2d4+1d2).(1d(4d6_3d3)) => 61
除最后一个测试用例外，所有其他情况都是通过参考实现生成的。
工作实例
表达： 1d((8d20t4T2)d(6d6R1r6)-2d4+1d2).(1d(4d6_3d3))
8d20t4T2 => [19, 5, 11, 6, 19, 15, 4, 20]t4T2 => [4, 5, 6, 11]T2 => [11, 6]（全：1d(([11, 6])d(6d6R1r6)-2d4+1d2).(1d(4d6_3d3))）6d6R1r6 => [2, 5, 1, 5, 2, 3]r1R6 => [2, 5, 3, 5, 2, 3]R6 => [2, 5, 3, 5, 2, 3]（1d([11, 6]d[2, 5, 3, 5, 2, 3]-2d4+1d2).(1d(4d6_3d3))）[11, 6]d[2, 5, 3, 5, 2, 3] => 17d20 => [1, 6, 11, 7, 2, 8, 15, 3, 4, 18, 11, 11, 1, 10, 8, 6, 11]（1d([1, 6, 11, 7, 2, 8, 15, 3, 4, 18, 11, 11, 1, 10, 8, 6, 11]-2d4+1d2).(1d(4d6_3d3))）2d4 => 7（1d([1, 6, 11, 7, 2, 8, 15, 3, 4, 18, 11, 11, 1, 10, 8, 6, 11]-7+1d2).(1d(4d6_3d3))）1d2 => 2（1d([1, 6, 11, 7, 2, 8, 15, 3, 4, 18, 11, 11, 1, 10, 8, 6, 11]-7+2).(1d(4d6_3d3))）[1, 6, 11, 7, 2, 8, 15, 3, 4, 18, 11, 11, 1, 10, 8, 6, 11]-7+2 => 133-7+2 => 128（1d128).(1d(4d6_3d3))）4d6_3d3 => [1, 3, 3, 6]_[3, 2, 2] => [1, 3, 3, 6, 3, 2, 2]（1d128).(1d[1, 3, 3, 6, 3, 2, 2])）1d[1, 3, 3, 6, 3, 2, 2] => 1d20 => 6（1d128).(6)）1d128 => 55（55.6）55.6 => [55, 6]（[55, 6]）[55, 6] => 61（完成）
参考实施
此参考实现使用相同的常量种子（0）来评估每个表达式的可测一致输出。它期望在STDIN上输入，并用换行符分隔每个表达式。
#!/usr/bin/env python3
import re
from random import randint, seed
from collections import Iterable
from functools import total_ordering
def as_list(x):
if isinstance(x, Iterable):
return list(x)
else:
return [x]
def roll(num_sides):
return Die(randint(1, num_sides), num_sides)
def roll_many(num_dice, num_sides):
num_dice = sum(as_list(num_dice))
num_sides = sum(as_list(num_sides))
return [roll(num_sides) for _ in range(num_dice)]
def reroll(dice, values):
dice, values = as_list(dice), as_list(values)
return [die.reroll() if die in values else die for die in dice]
def reroll_all(dice, values):
dice, values = as_list(dice), as_list(values)
while any(die in values for die in dice):
dice = [die.reroll() if die in values else die for die in dice]
return dice
def take_low(dice, num_values):
dice = as_list(dice)
num_values = sum(as_list(num_values))
return sorted(dice)[:num_values]
def take_high(dice, num_values):
dice = as_list(dice)
num_values = sum(as_list(num_values))
return sorted(dice, reverse=True)[:num_values]
def add(a, b):
a = sum(as_list(a))
b = sum(as_list(b))
return a+b
def sub(a, b):
a = sum(as_list(a))
b = sum(as_list(b))
return max(a-b, 1)
def concat(a, b):
return as_list(a)+as_list(b)
def list_diff(a, b):
return [x for x in as_list(a) if x not in as_list(b)]
@total_ordering
class Die:
def __init__(self, value, sides):
self.value = value
self.sides = sides
def reroll(self):
self.value = roll(self.sides).value
return self
def __int__(self):
return self.value
__index__ = __int__
def __lt__(self, other):
return int(self) < int(other)
def __eq__(self, other):
return int(self) == int(other)
def __add__(self, other):
return int(self) + int(other)
def __sub__(self, other):
return int(self) - int(other)
__radd__ = __add__
__rsub__ = __sub__
def __str__(self):
return str(int(self))
def __repr__(self):
return "{} ({})".format(self.value, self.sides)
class Operator:
def __init__(self, str, precedence, func):
self.str = str
self.precedence = precedence
self.func = func
def __call__(self, *args):
return self.func(*args)
def __str__(self):
return self.str
__repr__ = __str__
ops = {
'd': Operator('d', 3, roll_many),
'r': Operator('r', 2, reroll),
'R': Operator('R', 2, reroll_all),
't': Operator('t', 2, take_low),
'T': Operator('T', 2, take_high),
'+': Operator('+', 1, add),
'-': Operator('-', 1, sub),
'.': Operator('.', 1, concat),
'_': Operator('_', 1, list_diff),
}
def evaluate_dice(expr):
return max(sum(as_list(evaluate_rpn(shunting_yard(tokenize(expr))))), 1)
def evaluate_rpn(expr):
stack = []
while expr:
tok = expr.pop()
if isinstance(tok, Operator):
a, b = stack.pop(), stack.pop()
stack.append(tok(b, a))
else:
stack.append(tok)
return stack[0]
def shunting_yard(tokens):
outqueue = []
opstack = []
for tok in tokens:
if isinstance(tok, int):
outqueue = [tok] + outqueue
elif tok == '(':
opstack.append(tok)
elif tok == ')':
while opstack[-1] != '(':
outqueue = [opstack.pop()] + outqueue
opstack.pop()
else:
while opstack and opstack[-1] != '(' and opstack[-1].precedence > tok.precedence:
outqueue = [opstack.pop()] + outqueue
opstack.append(tok)
while opstack:
outqueue = [opstack.pop()] + outqueue
return outqueue
def tokenize(expr):
while expr:
tok, expr = expr[0], expr[1:]
if tok in "0123456789":
while expr and expr[0] in "0123456789":
tok, expr = tok + expr[0], expr[1:]
tok = int(tok)
else:
tok = ops[tok] if tok in ops else tok
yield tok
if __name__ == '__main__':
import sys
while True:
try:
dice_str = input()
seed(0)
print("{} => {}".format(dice_str, evaluate_dice(dice_str)))
except EOFError:
exit()[1]：我们的定义adb为矩阵参数是辊AdX对每个X在a * b其中A = det(a * b)。显然，对于这个挑战来说太荒谬了。
沙盒链接
—
-Mego
有了这样的保证
—
Christian Sievers
-，我b将永远无法a获得非正整数，因此第二条附加规则似乎毫无意义。OTOH _可能会导致列表为空，这在相同情况下似乎很有用，但是当需要整数时又意味着什么呢？通常我会说总和是0……
@ChristianSievers 1）为了清楚起见，我添加了有关非正整数的附加说明。2）空列表的总和为
—
Mego
0。根据非非正则规则，它将被评估为1。
可以，但是作为中间结果可以吗？所以
—
Christian Sievers
[1,2]_([1]_[1])是[1,2]？
@ChristianSievers不。这将导致
—
Mego
[2]，因为[1]_[1] -> [] -> 0 -> 1 -> [1]。