21

ルール

文字列をパラメーターとして受け取り、式の評価値をサイコロ表記で返す関数を作成します。これには加算と乗算が含まれます。

物事を明確にするために、法的な表現のEBNF定義を次に示します。

roll ::= [positive integer], "d", positive integer
entity ::= roll | positive number
expression ::= entity { [, whitespace], "+"|"*"[, whitespace], entity }

入力例:

  • 「3d6+12」
  • 「4*d12 + 3」
  • 「d100」

eval関数などの使用は禁止されていませんが、これらを使用せずに解決することをお勧めします。再入学大歓迎です。

出力はランダムでなければならないため、テストケースを提供することはできません;)。

回答のタイトルのフォーマット: 言語、n 文字 (重要な注意 — 評価なしなど)

私のルビーソリューション、9281 文字、eval を使用:

def f s
eval s.gsub(/(\d+)?d(\d+)/i){eval"a+=rand $2.to_i;"*a=($1||1).to_i}
end

もう 1 つのRubyソリューションは、短くはありません (92 文字) ですが、興味深いと思います。これはまだ eval を使用していますが、今回は非常に創造的な方法です。

class Fixnum
def**b
eval"a+=rand b;"*a=self
end
end
def f s
eval s.gsub(/d/,'**')
end
4

14 に答える 14

13

C＃クラス。加算と乗算を再帰的に評価し、連鎖ダイスロールを左から右に評価します。

編集：

  • .Replace(" ","")呼び出しごとに削除
  • 代わり.Trim()に追加int.TryParse
  • すべての作業が単一の方法で行われるようになりました
  • ダイフェースカウントが指定されていない場合、6と見なされます（Wiki記事を参照）
  • 「d」の左側を解析するためのリファクタリングされた冗長呼び出し
  • リファクタリングされた不要なifステートメント

縮小：（411バイト）

class D{Random r=new Random();public int R(string s){int t=0;var a=s.Split('+');if(a.Count()>1)foreach(var b in a)t+=R(b);else{var m=a[0].Split('*');if(m.Count()>1){t=1;foreach(var n in m)t*=R(n);}else{var d=m[0].Split('d');if(!int.TryParse(d[0].Trim(),out t))t=0;int f;for(int i=1;i<d.Count();i++){if(!int.TryParse(d[i].Trim(),out f))f=6;int u=0;for(int j=0;j<(t== 0?1:t);j++)u+=r.Next(1,f);t+=u;}}}return t;}}

拡張フォーム：

    class D
    {
        /// <summary>Our Random object.  Make it a first-class citizen so that it produces truly *random* results</summary>
        Random r = new Random();

        /// <summary>Roll</summary>
        /// <param name="s">string to be evaluated</param>
        /// <returns>result of evaluated string</returns>
        public int R(string s)
        {
            int t = 0;

            // Addition is lowest order of precedence
            var a = s.Split('+');

            // Add results of each group
            if (a.Count() > 1)
                foreach (var b in a)
                    t += R(b);
            else
            {
                // Multiplication is next order of precedence
                var m = a[0].Split('*');

                // Multiply results of each group
                if (m.Count() > 1)
                {
                    t = 1; // So that we don't zero-out our results...

                    foreach (var n in m)
                        t *= R(n);
                }
                else
                {
                    // Die definition is our highest order of precedence
                    var d = m[0].Split('d');

                    // This operand will be our die count, static digits, or else something we don't understand
                    if (!int.TryParse(d[0].Trim(), out t))
                        t = 0;

                    int f;

                    // Multiple definitions ("2d6d8") iterate through left-to-right: (2d6)d8
                    for (int i = 1; i < d.Count(); i++)
                    {
                        // If we don't have a right side (face count), assume 6
                        if (!int.TryParse(d[i].Trim(), out f))
                            f = 6;

                        int u = 0;

                        // If we don't have a die count, use 1
                        for (int j = 0; j < (t == 0 ? 1 : t); j++)
                            u += r.Next(1, f);

                        t += u;
                    }
                }
            }

            return t;
        }
    }

テストケース：

    static void Main(string[] args)
    {
        var t = new List<string>();
        t.Add("2d6");
        t.Add("2d6d6");
        t.Add("2d8d6 + 4d12*3d20");
        t.Add("4d12");
        t.Add("4*d12");
        t.Add("4d"); // Rolls 4 d6

        D d = new D();
        foreach (var s in t)
            Console.WriteLine(string.Format("{0}\t{1}", d.R(s), s));
    }
于 2009-06-23T19:24:07.110 に答える
5

J

コバルの助けを借りて、すべてを 93 文字に絞り込みます。

$ jconsole
   e=:".@([`('%'"_)@.(=&'/')"0@,)@:(3 :'":(1".r{.y)([: +/>:@?@$) ::(y&[)0".}.y}.~r=.y i.''d'''@>)@;:

   e '3d6 + 12'
20
   e 10$,:'3d6 + 12'
19 23 20 26 24 20 20 20 24 27
   e 10$,:'4*d12 + 3'
28 52 56 16 52 52 52 36 44 56
   e 10$,:'d100'
51 51 79 58 22 47 95 6 5 64
于 2009-06-24T02:46:26.700 に答える
4

F＃（評価なし、正規表現なし）

233文字

このソリューションは、次のようなクレイジーなものであっても、スローするほぼすべての文字列を処理できるという点で、完全に汎用的である必要があります。

43d29d16d21 * 9 + d7d9 * 91 + 2 * d24 * 7

これをグローバルに定義する必要があります。

let r = new System.Random()

完全に難読化されたバージョン：

let f(s:string)=let g d o i p (t:string)=t.Split([|d|])|>Array.fold(fun s x->o s (p x))i in g '+'(+)0(g '*' (*) 1 (fun s->let b=ref true in g 'd'(+)1(fun t->if !b then b:=false;(if t.Trim()=""then 1 else int t)else r.Next(int t))s))s

読み取り可能なバージョン：

let f (s:string) =
    let g d o i p (t:string) =
        t.Split([|d|]) |> Array.fold (fun s x -> o s (p x)) i
    g '+' (+) 0 (g '*' (*) 1 (fun s ->
                                        let b = ref true
                                        g 'd' (+) 1 (fun t ->
                                        if !b then b := false; (if t.Trim() = "" then 1 else int t)
                                        else r.Next(int t)) s)) s

正規表現を使用せずに、このソリューションを（任意の言語で）打ち負かすように誰かに挑戦しています。eval可能性は高いと思いますが、それでもアプローチに興味があります。

于 2009-06-24T17:03:54.683 に答える
4

Clojure、854文字そのまま、412文字縮小

"(roll-dice " input-string ")" を実行するだけです。

(defn roll-dice
  [string]
  (let [parts (. (. (. string replace "-" "+-") replaceAll "\\s" "") split "\\+")
        dice-func (fn [d-notation]
                    (let [bits (. d-notation split "d")]
                      (if (= 1 (count bits))
                        (Integer/parseInt (first bits))  ; Just a number, like 12
                        (if (zero? (count (first bits)))
                          (inc (rand-int (Integer/parseInt (second bits))))  ; Just d100 or some such
                          (if (. (first bits) contains "*")
                            (* (Integer/parseInt (. (first bits) replace "*" ""))
                                (inc (rand-int (Integer/parseInt (second bits)))))
                            (reduce +
                              (map #(+ 1 %)
                                    (map rand-int
                                        (repeat
                                          (Integer/parseInt (first bits))
                                          (Integer/parseInt (second bits)))))))))))]      
    (reduce + (map dice-func parts))))

縮小するために、変数を 1 文字にし、(最初のビット)/(2 番目のビット) を変数に移動し、dice-func を匿名関数にし、'i' という Integer.parseInt のラッパーを作成し、コメントと余分な空白を取り除きました。 .

これは、空白の有無にかかわらず、有効なもので機能するはずです。「15dROBERT」を要求しないでください。例外がスローされます。

彼らのやり方は、文字列をサイコロに分割することです（それは3行目、レットです）。したがって、「5d6+2*d4-17」は「5d6」、「2*d4」、「-17」になります。

次に、それらのそれぞれが関数 dice-func によって処理され、結果が加算されます (これは最後の行の map/reduce です)。

Dice-func は、小さなサイコロ文字列 ("5d6" など) を取り、それを "d" で分割します。1 つの部分しか残っていない場合、それは単純な数字 (6、-17 など) でした。

最初の部分に * が含まれている場合、その数値に 1 から (d の後の数値) までのランダムな整数を乗算します。

最初の部分に * が含まれていない場合、(前の行と同様に) 最初の数のランダム ロールを取得し、それらを加算します (これは中央のマップ/リデュースです)。

これは楽しい小さな挑戦でした。

于 2009-06-23T23:44:44.353 に答える
4

perl評価版、72 文字

sub e{$_=pop;s/(\d+)?d(\d+)/\$a/i;$a+=1+int rand$2-1for 0...$1-1;eval$_}

のように走る

print e("4*d12+3"),"\n";

ruby ソリューションに基づいて、1 回だけ実行できます (実行undef $a間で実行する必要があります)。

短いバージョン、68 文字、ファンキー (0 ベース) ダイス

sub e{$_=pop;s/(\d+)?d(\d+)/\$a/i;$a+=int rand$2for 0...$1-1;eval$_}

編集

perl 5.8.8 は以前のバージョンが気に入らなかったため、動作する 73 文字のバージョンを次に示します。

sub e{$_=pop;s/(\d+)?d(\d+)/\$a/i;$a+=1+int rand$2-1for 1...$1||1;eval$_}

複数のロールをサポートする70文字バージョン

sub e{$_=pop;s/(\d*)d(\d+)/$a=$1||1;$a+=int rand$a*$2-($a-1)/ieg;eval}
于 2009-06-23T14:36:44.873 に答える
4

JavaScriptソリューション、圧縮時は 340 文字 (評価なし、接頭辞付き乗法子と接尾辞付き加算をサポート):

function comp (s, m, n, f, a) {
    m = parseInt( m );
    if( isNaN( m ) ) m = 1;
    n = parseInt( n );
    if( isNaN( n ) ) n = 1;
    f = parseInt( f );
    a = typeof(a) == 'string' ? parseInt( a.replace(/\s/g, '') ) : 0;
    if( isNaN( a ) ) a = 0;
    var r = 0;
    for( var i=0; i<n; i++ )
        r += Math.floor( Math.random() * f );
    return r * m + a;
};
function parse( de ) {
    return comp.apply( this, de.match(/(?:(\d+)\s*\*\s*)?(\d*)d(\d+)(?:\s*([\+\-]\s*\d+))?/i) );
}

テストコード:

var test = ["3d6 + 12", "4*d12 + 3", "d100"];
for(var i in test)
    alert( test[i] + ": " + parse(test[i]) );

圧縮バージョン (もっと短くできるはずです):

function c(s,m,n,f,a){m=parseInt(m);if(isNaN(m))m=1;n=parseInt(n);if(isNaN(n))n=1;f=parseInt(f);a=typeof(a)=='string'?parseInt(a.replace(/\s/g,'')):0;if(isNaN(a))a=0;var r=0;for(var i=0;i<n;i++)r+=Math.floor(Math.random()*f);return r*m+a;};function p(d){return c.apply(this,d.match(/(?:(\d+)\s*\*\s*)?(\d*)d(\d+)(?:\s*([\+\-]\s*\d+))?/i));}
于 2009-06-23T10:35:15.283 に答える
3

python、隠蔽バージョンで 197 文字。

読み取り可能なバージョン: 369 文字。評価なし、単純な解析。

import random
def dice(s):
    return sum(term(x) for x in s.split('+'))
def term(t):
    p = t.split('*')
    return factor(p[0]) if len(p)==1 else factor(p[0])*factor(p[1])
def factor(f):
    p = f.split('d')
    if len(p)==1:
        return int(f)
    return sum(random.randint(1, int(g[1]) if g[1] else 6) for \
               i in range(int(g[0]) if g[0] else 1))

圧縮バージョン: 258 文字、1 文字の名前、乱用された条件式、論理式のショートカット:

import random
def d(s):
 return sum(t(x.split('*')) for x in s.split('+'))
def t(p):
 return f(p[0])*f(p[1]) if p[1:] else f(p[0])
def f(s):
 g = s.split('d')
 return sum(random.randint(1, int(g[1] or 6)) for i in range(int(g[0] or 1))) if g[1:] else int(s)

隠蔽されたバージョン: 216 文字、reduce を使用し、「def」、「return」を避けるために重くマップします。

import random
def d(s):
 return sum(map(lambda t:reduce(lambda x,y:x*y,map(lambda f:reduce(lambda x,y:sum(random.randint(1,int(y or 6)) for i in range(int(x or 1))), f.split('d')+[1]),t.split('*')),1),s.split('+')))

最終バージョン: 197 文字、@Brain のコメントで折りたたまれ、テスト実行が追加されました。

import random
R=reduce;D=lambda s:sum(map(lambda t:R(int.__mul__,map(lambda f:R(lambda x,y:sum(random.randint(1,int(y or 6))for i in[0]*int(x or 1)),f.split('d')+[1]),t.split('*'))),s.split('+')))

テスト:

>>> for dice_expr in ["3d6 + 12", "4*d12 + 3","3d+12", "43d29d16d21*9+d7d9*91+2*d24*7"]: print dice_expr, ": ", list(D(dice_expr) for i in range(10))
... 
3d6 + 12 :  [22, 21, 22, 27, 21, 22, 25, 19, 22, 25]
4*d12 + 3 :  [7, 39, 23, 35, 23, 23, 35, 27, 23, 7]
3d+12 :  [16, 25, 21, 25, 20, 18, 27, 18, 27, 25]
43d29d16d21*9+d7d9*91+2*d24*7 :  [571338, 550124, 539370, 578099, 496948, 525259, 527563, 546459, 615556, 588495]

このソリューションは、隣接する数字のない空白を処理できません。したがって、「43d29d16d21*9+d7d9*91+2*d24*7」は機能しますが、「43d29d16d21*9 + d7d9*91 + 2*d24*7」は機能しません。2 番目のスペース (「+」と「」の間) のためです。 d")。最初に s から空白を削除することで修正できますが、これによりコードが 200 文字を超えてしまうため、バグはそのままにしておきます。

于 2009-06-23T16:59:35.950 に答える
3

Pythonは eval ありで 124 文字、なしで 154 文字。

Python が読み取り可能である必要がないことを示すために、オリジナルと同様の評価ベースのアプローチを使用した 124 文字のソリューションを次に示します。

import random,re
f=lambda s:eval(re.sub(r'(\d*)d(\d+)',lambda m:int(m.group(1)or 1)*('+random.randint(1,%s)'%m.group(2)),s))

[編集] そして、これは eval のない 154 文字のものです:

import random,re
f=lambda s:sum(int(c or 0)+sum(random.randint(1,int(b))for i in[0]*int(a or 1))for a,b,c in re.findall(r'(\d*)d(\d+)(\s*[+-]\s*\d+)?',s))

注: どちらも "2d6 + 1d3 + 5" などの入力に対しては機能しますが、"2d3d6" や負のサイコロなどのより高度なバリアントはサポートしていません ("1d6-4" は問題ありませんが、"1d6-2d4" はそうではありません) (代わりに、2 番目の文字で負の数をまったくサポートしないように、2 文字を削ることができます)。

于 2009-06-24T11:27:03.177 に答える
3

perl、評価なし、144 文字、複数回動作、複数のダイスロールをサポート

sub e{($c=pop)=~y/+* /PT/d;$b='(\d+)';map{$a=0while$c=~s!$b?$_$b!$d=$1||1;$a+=1+int rand$2for 1..$d;$e=$2;/d/?$a:/P/?$d+$e:$d*$e!e}qw(d T P);$c}

拡張版、コメント付き

sub f {
    ($c = pop); #assign first function argument to $c
    $c =~ tr/+* /PT/d;  #replace + and * so we won't have to escape them later.
                        #also remove spaces
    #for each of 'd','T' and 'P', assign to $_ and run the following
    map {
        #repeatedly replace in $c the first instance of <number> <operator> <number> with
        #the result of the code in second part of regex, capturing both numbers and
        #setting $a to zero after every iteration
        $a=0 while $c =~ s[(\d+)?$_(\d+)][
            $d = $1 || 1;   #save first parameter (or 1 if not defined) as later regex 
                            #will overwrite it
            #roll $d dice, sum in $a
            for (1..$d)
            {
                $a += 1 + int rand $2;
            }
            $e = $2;        #save second parameter, following regexes will overwrite
            #Code blocks return the value of their last statement
            if (/d/)
            {
                $a; #calculated dice throw
            }
            elsif (/P/)
            {
                $d + $e;
            }
            else
            {
                $d * $e;
            }
        ]e;
    } qw(d T P);
    return $c;
}

編集がクリーンアップされ、説明が最新バージョンに更新されました

于 2009-06-23T16:08:00.650 に答える
2

Ruby、166 文字、いいえeval

私の意見では、非常にエレガントです;）。

def g s,o=%w{\+ \* d}
o[a=0]?s[/#{p=o.pop}/]?g(s.sub(/(\d+)?\s*(#{p})\s*(\d+)/i){c=$3.to_i
o[1]?($1||1).to_i.times{a+=rand c}+a:$1.to_i.send($2,c)},o<<p):g(s,o):s
end

難読化解除されたバージョン + コメント:

def evaluate(string, opers = ["\\+","\\*","d"])
  if opers.empty?
    string
  else
    if string.scan(opers.last[/.$/]).empty? # check if string contains last element of opers array

      # Proceed to next operator from opers array.

      opers.pop
      evaluate(string, opers)

    else # string contains that character...

      # This is hard to deobfuscate. It substitutes subexpression with highest priority with
      # its value (e.g. chooses random value for XdY, or counts value of N+M or N*M), and
      # calls recursively evaluate with substituted string.

      evaluate(string.sub(/(\d+)?\s*(#{opers.last})\s*(\d+)/i) { a,c=0,$3.to_i; ($2 == 'd') ? ($1||1).to_i.times{a+=rand c}+a : $1.to_i.send($2,c) }, opers)

    end
  end
end
于 2009-06-24T15:09:17.190 に答える
1

JAVASCRIPT、1399文字、評価なし

古い投稿、知っています。しかし、私は貢献しようとします

Roll = window.Roll || {};

Roll.range = function (str) {
    var rng_min, rng_max, str_split,
        delta, value;

    str = str.replace(/\s+/g, "");
    str_split = str.split("-");
    rng_min = str_split[0];
    rng_max = str_split[1];

    rng_min = parseInt(rng_min) || 0;
    rng_max = Math.max(parseInt(rng_max), rng_min) || rng_min;

    delta = (rng_max - rng_min + 1);

    value = Math.random() * delta;
    value = parseInt(value);

    return value + rng_min;
};

Roll.rollStr = function (str) {
    var check,
        qta, max, dice, mod_opts, mod,
        rng_min, rng_max,
        rolls = [], value = 0;

    str = str.replace(/\s+/g, "");
    check = str.match(/(?:^[-+]?(\d+)?(?:\/(\d+))?[dD](\d+)(?:([-+])(\d+)\b)?$|^(\d+)\-(\d+)$)/);

    if (check == null) {return "ERROR"}
    qta = check[1];
    max = check[2];
    dice = check[3];
    mod_opts = check[4];
    mod = check[5];
    rng_min = check[6];
    rng_max = check[7];
    check = check[0];

    if (rng_min && rng_max) {return Roll.range(str)}

    dice = parseInt(dice);
    mod_opts = mod_opts || "";
    mod = parseInt(mod) || 0;
    qta = parseInt(qta) || 1;
    max = Math.max(parseInt(max), qta) || qta;

    for (var val; max--;) {
        val = Math.random() * dice;
        val = Math.floor(val) + 1;
        rolls.push(val);
    }

    if (max != qta) {
        rolls.sort(function (a, b) {return a < b});
        rolls.unshift(rolls.splice(0, qta));
    }

    while (rolls[0][0]) {value += rolls[0].shift();}

    if (mod_opts == "-") {value -= mod;}
    else {value += mod;}

    return value
};

if (!window.diceRoll) {window.diceRoll= Roll.rollStr;}

「2d8+2」または「4-18」「3/4d6」（4 d6 のうちの 3 がベスト）のような 1 つのサイコロのロールです。

diceRoll("2d8+2"); 
diceRoll("4-18");
diceRoll("3/4d6");

累積ロールをチェックするには、次のような入力文字列に対して一致した結果をループする方が良い

r = "2d8+2+3/4d6"
r.match(/([-+])?(\d+)?(?:\/(\d+))?[dD](\d+)(?:([-+])(\d+)\b)?/g);
// => ["2d8+2", "+3/4d6"]
// a program can manage the "+" or "-" on the second one (usually is always an addiction)
于 2014-07-24T09:44:25.613 に答える
0

PHP、147シンボル、評価なし：

preg_match('/(\d+)?d(\d+)[\s+]?([\+\*])?[\s+]?(\d+)?/',$i,$a);$d=rand(1,$a[2])*((!$a[1])?1:$a[1]);$e['+']=$d+$a[4];$e['*']=$d*$a[4];print$e[$a[3]];

$i入力文字列が含まれます。

編集：おっと、接頭辞付きの操作を忘れました。すぐに戻る。

于 2009-06-25T15:12:51.717 に答える