পটভূমি
আমি কিছু বন্ধুদের সাথে নিয়মিত ডিঅ্যান্ডডি খেলি। কিছু সিস্টেম / সংস্করণগুলির জটিলতা সম্পর্কে কথা বলার সময় যখন ডাইস রোলিংয়ের বিষয়টি আসে এবং বোনাস এবং জরিমানা প্রয়োগ করা হয়, আমরা রসিকভাবে ডাইস রোলিং এক্সপ্রেশনগুলির জন্য কিছু অতিরিক্ত জটিলতা নিয়ে এসেছি। তাদের মধ্যে কিছু খুব আপত্তিজনক ছিল ( 2d6ম্যাট্রিক্স আর্গুমেন্ট 1 এর মতো সাধারণ ডাইস এক্সপ্রেশনগুলি বাড়ানো ), তবে বাকীগুলি একটি আকর্ষণীয় সিস্টেমের জন্য তৈরি করে make
চ্যালেঞ্জ
একটি জটিল পাশা এক্সপ্রেশন দেওয়া, নিম্নলিখিত নিয়ম অনুসারে এটি মূল্যায়ন এবং ফলাফল ফলাফল।
বেসিক মূল্যায়ন বিধি
- যখনই কোনও অপারেটর একটি পূর্ণসংখ্যার প্রত্যাশা করে তবে কোনও অপরেন্ডের জন্য একটি তালিকা গ্রহণ করে, সেই তালিকার যোগফলটি ব্যবহৃত হয়
- যখনই কোনও অপারেটর একটি তালিকা প্রত্যাশা করে তবে কোনও অপরেন্ডের জন্য একটি পূর্ণসংখ্যা গ্রহণ করে, পূর্ণসংখ্যাটি সেই সংখ্যার একটি উপাদান হিসাবে তালিকা হিসাবে বিবেচিত হয়
অপারেটর
সমস্ত অপারেটর বাইনারি ইনফিক্স অপারেটর। ব্যাখ্যার উদ্দেশ্যে, aবাম অপারেন্ড bহবে এবং ডান অপারেন্ড হবে। তালিকার স্বরলিপি উদাহরণগুলির জন্য ব্যবহৃত হবে যেখানে অপারেটরগুলি অপারেটর হিসাবে তালিকা নিতে পারে তবে প্রকৃত প্রকাশগুলি কেবলমাত্র ইতিবাচক পূর্ণসংখ্যা এবং অপারেটর নিয়ে গঠিত of
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, ব্যবহার করছেন তাদের উপাদান reroll যাই হোক না কেন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, যারা উপাদান বারবার reroll পর্যন্ত কোন উপাদান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একসাথে- নজির: ১
- উভয় অপারেন্ডগুলি পূর্ণসংখ্যা
- উদাহরণ:
2+2 => 4,[2]+[2] => 4,[3, 1]+2 => 6
-:bথেকে বিয়োগa- নজির: ১
- উভয় অপারেন্ডগুলি পূর্ণসংখ্যা
bসবসময় কম হবেa- উদাহরণ:
2-1 => 1,5-[2] => 3,[8, 3]-1 => 10
.: একত্রেaএবংbএকসাথে- নজির: ১
- উভয় অপারেশন তালিকা
- উদাহরণ:
2.2 => [2, 2],[1].[2] => [1, 2],3.[4] => [3, 4]
_: সরানোaসমস্ত উপাদান সহ আউটপুটb- নজির: ১
- উভয় অপারেশন তালিকা
- উদাহরণ:
[3, 4]_[3] => [4],[2, 3, 3]_3 => [2],1_2 => [1]
অতিরিক্ত বিধি
- যদি একটি এক্সপ্রেশনের চূড়ান্ত মান একটি তালিকা হয় তবে এটি আউটপুট দেওয়ার আগে যোগ করা হয়
- পদ মূল্যায়ন শুধুমাত্র ধনাত্মক পূর্ণসংখ্যা বা ধনাত্মক পূর্ণসংখ্যা তালিকা পরিণাম ডেকে আনবে - কোনো অভিব্যক্তি একটি অ-ধনাত্মক পূর্ণসংখ্যা বা অন্তত এক অ ধনাত্মক পূর্ণসংখ্যা ধারণকারী যারা মান দ্বারা প্রতিস্থাপিত হবে একটি তালিকাতে ফলাফল
1গুলি - প্যারেন্টিহেসগুলি শর্তাদি গোষ্ঠী করতে এবং মূল্যায়নের ক্রম নির্দিষ্ট করতে ব্যবহার করা যেতে পারে
- অপারেটরগুলি সর্বনিম্ন অগ্রগতির সর্বাধিক অগ্রাধিকারের ভিত্তিতে মূল্যায়ন করা হয়, বাঁধা অগ্রাধিকারের ক্ষেত্রে মূল্যায়ন বাম থেকে ডানে অগ্রসর হয় (সুতরাং
1d4d4মূল্যায়ন হবে(1d4)d4) - তালিকাগুলিতে উপাদানগুলির ক্রম কোনও ব্যাপার নয় - এটি অপারেটরের পক্ষে পুরোপুরি গ্রহণযোগ্য যা কোনও তালিকাটিকে তার উপাদানগুলির সাথে এটি অন্য কোনও আপেক্ষিক ক্রমে ফিরিয়ে দিতে পরিবর্তন করে for
- যে শর্তাদি মূল্যায়ন করা যায় না বা অসীম লুপের (যেমন
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 * bA = det(a * b)
স্যান্ডবক্স লিঙ্ক
—
মেগো
সঙ্গে গ্যারান্টি
—
খ্রিস্টান সিভর্স
-যে bসবসময় কম হবে চেয়ে aআমি অ ধনাত্মক পূর্ণসংখ্যা পেতে কোন উপায়, তাই দ্বিতীয় অতিরিক্ত নিয়ম অর্থহীন বলে মনে হয়। ওটিওএইচ, _খালি তালিকার ফলস্বরূপ হতে পারে যা একই ক্ষেত্রে কার্যকর মনে হয় তবে যখন পূর্ণসংখ্যার প্রয়োজন হয় তখন এর অর্থ কী? সাধারণত আমি যোগফলটি বলতে চাই 0...
@ ক্রিশ্চিয়িয়ানসিভার্স ১) আমি স্বচ্ছতার জন্য ধনাত্মক পূর্ণসংখ্যার বিষয়ে অতিরিক্ত নোট যুক্ত করেছি। 2) একটি খালি তালিকার যোগফল
—
মেগো
0। অ-ধনাত্মক নিয়মের দ্বারা এটি হিসাবে মূল্যায়ন করা হবে 1।
ঠিক আছে, তবে মধ্যবর্তী ফলাফল হিসাবে এটি কি ঠিক আছে? তাই
—
খ্রিস্টান সিভর্স
[1,2]_([1]_[1])তো [1,2]?
@ChristianSievers নং সেই স্থাপিত হবে
—
মেগো
[2], কারণ [1]_[1] -> [] -> 0 -> 1 -> [1]।