问题

从n=2骰子开始：

• 辊n骰子，与每个数为1〜6同样有可能在每个管芯上。
• 检查它们的总和是否等于n骰子的最可能总和3.5*n。
  • 如果相等，则终止。
  • 否则，打印n，并从一开始就重复n+2骰子

您的代码不必完全执行此过程，但应根据我们对randomness的定义，在概率上与之等效的随机输出。

您的程序应将所有数字单独输出。例如，如果程序最多有8个骰子，并用8个骰子掷出最可能的数字，则输出为：

2
4
6

示例运行

在2个骰子上，7是最可能的和。假设滚动的数字是2和3。然后，您将打印2。

在4个骰子上，14是最可能的和。比方说推出的数字是3，4，2，和5。然后，总和为14，因此程序将在此处终止。

在这种情况下，最终输出为"2"。

规则

• 代码高尔夫球，以字节为单位的最短解决方案获胜
• 适用标准漏洞
• 随机性的元定义适用
• 您可以使用函数也可以使用程序

Python 2，70个字节

from random import*
n=2
while eval("+randrange(6)-2.5"*n):print n;n+=2

在线尝试！

诀窍是通过eval输入如下所示的字符串来计算总和

'+randrange(6)-2.5+randrange(6)-2.5'

带有n连接的表达式副本。的randrange(6)输出从一个随机数[0,1,2,3,4,5]，它由向下移位2.5以具有平均的0。当总和为if时0，while条件失败，循环终止。

另一种使用方式map是长4个字节：

from random import*
n=2
while sum(map(randrange,[6]*n))-2.5*n:print n;n+=2

我发现了一堆等长的骰子等长表达式转移为零，但都不短

randrange(6)-2.5
randint(0,5)-2.5
randrange(6)*2-5
uniform(-3,3)//1

MATL，13字节

`@E6y&Yrs@7*-

在线尝试！

说明

`       % Do...while top of the stack is truthy
  @E    %   Push 2*k, where k is the iteration index starting at 1
  6     %   Push 6
  y     %   Duplicate 2*k onto the top of the stack
  &Yr   %   Array of 2*k integers distributed uniformly in {1, 2, ..., 6}
  s     %   Sum
  @7*   %   Push 7*k
  -     %   Subtract
        % End (implicit). If the top of the stack is non-zero, the loop
        % proceeds with the next iteration. Else the loop is exited.
        % Display stack (implicit)

果冻， 19  14 字节

在Leaky Nun的帮助下-5字节（从计数到递归）

‘‘6ṗX_3.L⁶S?Ṅß

完整的程序将打印结果，并以换行符分隔（还会打印多余的空格和换行符，并在末尾显示程序错误）。

在线尝试！ -每次超过6个骰子，TIO都会由于占用内存而将其杀死，但是从原理上讲，它的工作原理-大约需要40秒钟。

不这么长时间，或需要这么多的内存更友好的15字节的版本可以在这里。

怎么样？

递归滚动2个骰子，直到每张减少3.5的面的总和为零，并随即打印骰子的数量，当达到零时，它尝试使用空格字符，导致类型错误。

‘‘6ṗX_3.L⁶S?Ṅß - Main link: no arguments (implicit left=zero)
‘              - increment (initial zero or the previous result)
 ‘             - increment  (= # of dice to roll, n)
  6            - literal 6
   ṗ           - Cartesian power - all possible rolls of n 6-sided dice with faces 1-6
    X          - pick one of them
      3.       - literal 3.5
     _         - subtract 3.5 from each of the roll results
           ?   - if:
          S    -          sum the adjusted roll results (will be 0 for most common)
        L      - ...then: length (number of dice that were rolled)
         ⁶     - ...else: literal ' ' (causes error when incremented in next step)
            Ṅ  - print that plus a newline
             ß - call this link with the same arity (as a monad with the result)

TI-BASIC，28个字节

2→N
While mean(randInt(1,6,N)-3.5
Disp N
N+2→N
End

说明

• randInt(1,6,N) 生成从1到6的N个随机数的列表
• mean(randInt(1,6,N)-3.5 滚动平均下降3.5
• While 继续直到平均表达式等于零（最可能的和）

R，49个字节

n=2
while(sum(sample(6,n,T)-3.5)){print(n)
n=n+2}

sample(6,n,T)生成具有替换n范围的（伪）随机样本1:6。sum如果且仅当它是最常见的值时，从每个元素中减去3.5会得出结果为0（假）。

在线尝试！

跳过奇数骰子。

爪哇8，123 149 113 108个字节

()->{for(int n=0,s=1,i;s!=n*7;){for(i=s=++n*2;i-->0;s+=Math.random()*6);if(s!=n*7)System.out.println(n*2);}}

或107字节，如果我们使用的Object null是未使用的参数来代替。

+26字节的错误修复程序，由@Jules在注释中正确指出。
-41字节感谢@OliverGrégoire的出色思考！

说明：

在这里尝试。

()->{                           // Method without parameter nor return-type
  for(int n=0,                  //  Amount of dice
          s=1,                  //  Sum
          i;                    //  Index
      s!=n*7;){                 //  Loop (1) as long as the sum doesn't equal `n`*7,
                                //  because we roll the dice per two, and 3.5*2=7
    for(i=s=++n*2;              //   Reset both the index and sum to `n`*2,
                                //   so we can use random 0-5, instead of 1-6
                                //   and we won't have to use `+1` at `Math.random()*6`
        i-->0;                  //   Inner loop (2) over the amount of dice
        s+=Math.random()*6      //    And increase the sum with their random results
    );                          //   End of inner loop (2)
    if(s!=n*7)                  //   If the sum doesn't equal `n`*7
      System.out.println(n*2);  //    Print the amount of dice for this iteration 
  }                             //  End of loop (1)
}                               // End of method

05AB1E，22 20字节

-2字节归功于Emigna

[YF6L.RO}7Y*;ïQ#Y=ÌV

在线尝试！

说明

[YF6L.RO}7Y*;ïQ#Y=ÌV
[                    # Infinite loop start
 YF     }            # Y times... (Y defaults to 2)
   6L.R               # Push a random number between 1 and 6 (why does this have to be so looooong ._.)
       O              # Sum
         7Y*;ï       # Push 3.5 * Y as an int
              Q      # Is it equal to 3.5 * Y?
               #     # If so: Quit
                Y    # Push Y
                 =   # Print without popping
                  ÌV # Set Y to Y + 2

R，48 44 42字节

朱塞佩的答案提高了5个字节。

while(sum(sample(6,F<-F+2,1)-3.5))print(F)

这（ab）利用了以下事实：F默认情况下，FALSE该变量是分配给该变量的变量，0然后可以递增该变量，从而节省了初始化计数器变量的需要。

的PHP，75字节

for($d=2;(++$i*7/2-$r+=rand(1,6))||$i<$d;)$i%$d?:$d+=1+print"$d
".$r=$i="";

在线尝试！

GolfScript，41个字节

0{2+.n\.[{6rand.+5-}*]{+}*!!*.}{}while;;;

在线尝试！

Mathematica，47个字节

For[n=1,Tr@RandomInteger[5,2n++]!=5n,Print[2n]]

LLlAMnYP中的-5个字节

05AB1E，17个字节

[N·ÌD6Lã.R7;-O_#,

在线尝试！

说明

[                   # loop over N in 0...
 N·Ì                # push N*2+2
    D               # duplicate
     6L             # push range [1 ... 6]
       ã            # cartesian product (combinations of N*2+2 elements in range)
        .R          # pick one at random
          7;-       # subtract 3.5 from each dice roll
             O_#    # if sum == 0 exit loop
                ,   # otherwise print the copy of N*2+2

批次，109个字节

@set/an=%1+2,s=n*5/2
@for /l %%i in (1,1,%n%)do @call set/as-=%%random%%%%%%6
@if %s% neq 0 echo %n%&%0 %n%

令人讨厌的random是，它是一个神奇的环境变量，因此它仅在环境扩展过程中被替换为随机值，通常在for循环开始之前发生。call使其在每次循环中都发生，但是您需要加倍%符号以防止在循环之前发生扩展。有趣的开始是因为我们想将结果乘以6，这需要一个实数%，现在必须将其加倍两次。结果是六个连续的%s。

JavaScript（ES2015），75 78字节

f=(n=2)=>[...Array(n)].reduce(a=>a+Math.random()*6|0,n)==3.5*n?'':n+`
`+f(n+2)

输出以换行符分隔的结果字符串

编辑：感谢Shaggy，保存了一个字节，添加了4个字节以从2开始功能

说明

f=n=>
  [...Array(n)]                // Array of size n
    .reduce(                   // Combine each item
      a=>a+Math.random()*6|0,  // Add a random roll between 0 and 5 for each item
    n)                         // Start at n to correct rolls to between 1 and 6
    ==3.5*n                    // Compare total to most probable roll total
  ? ''                         // If true, end
  : n+'\n'+f(n+2)              // Otherwise, output n and continue

f=(n=2)=>[...Array(n)].reduce(a=>a+Math.random()*6|0,n)==3.5*n?'':n+`
`+f(n+2)

let roll = _ => document.getElementById('rolls').innerHTML = f();
document.getElementById('roll-button').onclick = roll;
roll();

<button id="roll-button">Roll</button>
<pre id="rolls"></pre>

php-89个字符

$r=0;$n=2;while($r!=$n*3.5){$r=$i=0;while($i<$n){$r+=rand(1,6);$i++;}print $n."
";$n+=2;}

C (gcc), 84 80 79 77 75 80 78 76 bytes

i;f(s,j){for(;s;s?printf("%d\n",i):0)for(j=i+=2,s=i*7/2;j--;)s-=1+rand()%6;}

Try it online!

Haskell 133 132 bytes

import System.Random;import Control.Monad
s k=do n<-replicateM k$randomRIO(1,6);if sum n==7*div k 2 then pure()else do print k;s(k+2)

Credit to @Laikoni for the suggestions in the comments below.

Octave 55 bytes

n=2;
while mean(randi(6,n,1))-3.5!=0
n
n=n+2;
end

Inspired by Andrewarchi's answer. If someone has any pointers to even shorten it, they are welcome.

Pyth, 20 bytes

K2WnsmhO6K*K3.5K=+K2

Try it online!

QBIC, 40 bytes

{[1,r|g=g+_r1,6|]~g=r*3.5|_X\g=0?r┘r=r+2

Thispretty much literally does what the challenge asks for; seems the shortest way to get the distribution right.

Explanation

{          DO infinitely
[1,r|      FOR a=1, a<=r (at start, r == 2), a++
g=g+       Add to g (0 at start)
  _r1,6|   a random number between 1 and 6 incl.
]          NEXT
~g=r*3.5   IF the result of all dice rolls equals the expected value
|_X        THEN quit
\g=0       ELSE, reset the dice total
?r┘        PRINT the number of dice used
r=r+2      and add 2 dice.
           END IF and LOOP are courtiously provided by QBIC at EOF.

Rexx (Regina), 78 bytes

x=2
do forever
  t=0
  do x
    t=t+random(6)
  end
  if(t=x*3.5)then
    exit
  say x
  x=x+2
end

Try it online!

JavaScript (ES6) - 69 Characters

r=n=>n?r(n-1)+(Math.random()*6|0)-2.5:0;f=(n=2)=>r(n)?n+`
`+f(n+2):""

console.log(f())

Explanation:

r=n=>                                     # Roll n dice
     n?                                   # If there is a dice left to roll
       r(n-1)                             #   Roll n-1 dice
             +(Math.random()*6|0)         #   Add a random number from 0 .. 5
                                 -2.5     #   Subtract 2.5 so sum of average is 0
                                     :0   # Else total is 0

and:

f=(n=2)=>                                 # Start with n = 2
         r(n)                             # Roll n dice
             ?n+"\n"+f(n+2)               # If non-zero then concatenate n, newline and
                                          #    result for n+2 dice
                           :""            # If zero (average) terminate.

Calc2 0.7, 119 118 111 bytes

using"runtime";for(n=2,d=0;d!=3.5*n;Console.WriteLine(n),n+=2)for(i=d=0;i++<n;)d+=Math.Int(Random().Next(1,7));

ungolfed:

using "runtime";
var d = 0;
var r = Random();
for(var n = 2; d != 3.5 * n; Console.WriteLine(n), n += 2)
{
    d = 0;
    for(var i = 0; i < n; i++)
        d += Math.Int(r.Next(1,7));
}

I could do without the Math.Int() but unfortunately in 0.7 the Random().Next() functions have a bug where they all return doubles instead of ints. It has been fixed but only after this question was posted. I'm not gonna win anything, but hey, nice proof of concept.

Edit:

• removed unnecessary space between using and "runtime" (-1 byte)

Edit2:

• removed var r and create a new Random where it's needed (-4 byte)

• changed i=0,d=0 to i=d=0 (-2 byte)

• incremented i after check (-1 byte)

Ruby, 52 bytes

s=x=2;(s=0;p x.times{s+=rand(6)-2.5};x+=2)while s!=0

Explanation

s=x=2;                                                # sum=2, x=2
      (                                  )while s!=0  # while sum != 0:
       s=0;                                           #  reset the sum
           p                                          #  print
             x.times{              };                 #  repeat x times:
                     s+=                              #   Add to sum:
                        rand(6)                       #    random int in 0..5
                               -2.5                   #    subtract average
                                                      #  (implicitly return x for printing)
                                     x+=2             #  Increment x by 2

Try it online!

Javascript, 87 chars

for(n=2;eval('+'.repeat(n).replace(/./g,x=>x+(Math.random()*6|0)))!=2.5*n;n+=2)alert(n)

Test with console.log instead of alert:

for(n=2;eval('+'.repeat(n).replace(/./g,x=>x+(Math.random()*6|0)))!=2.5*n;n+=2)console.log(n)
console.log('Done')

lua, 102 bytes

function r(n,t) for d=1,n do t=t+math.random(1,6)end return t==n*3.5 or print(n)or r(n+2,0)end r(2,0)

Or the more readable version

function r(n,t) --recursive function does its magic, t is given to safe usage bytes(no local)
    for d=1,n do --roll n dice and count them up to the total (t)
         t =t+math.random(1,6)
    end 
    return t==n*3.5 or --check if t==n*3.5. If it is then it ends
           print(n) or --t != n*3.5 thus print n. print returns nil
           r(n+2,0) --both the check and the return value from print are false thus r gets executed.
end 
r(2,0) --start the process

A more cheaty version for 96 bytes

function r(n,t,m)t=t+m(1,6)+m(1,6)return t==n*3.5 or print(n)or r(n+2,t,m)end r(2,0,math.random)

This pretty much works the same as the first but reuses the rolls from earlier calls. Because of this I can remove the for loop. Both are tested in lua 5.2

Perl 6, 48 bytes

.say for 2,*+2...^{3.5*$_==sum (1..6).pick xx$_}

PHP, 51 bytes

$r=2;$n=2;while(rand(0,6)-2.5*$r){print $n;$n=$n+2;}