Vấn đề

Bắt đầu từ n=2súc sắc:

• Lăn nxúc xắc, với mỗi số 1 đến 6 có khả năng như nhau trên mỗi lần chết.
• Kiểm tra xem tổng của chúng có bằng tổng có thể xảy ra nhất đối với nsúc sắc không, nghĩa là 3.5*n.
  • Nếu chúng bằng nhau, chấm dứt.
  • Mặt khác, in nvà lặp lại từ đầu với n+2xúc xắc

Mã của bạn không phải thực hiện thủ tục này một cách chính xác, nhưng sẽ cho đầu ra ngẫu nhiên có xác suất tương đương với nó, dựa trên định nghĩa về tính ngẫu nhiên của chúng tôi .

Chương trình của bạn sẽ xuất tất cả các số trên dòng riêng của chúng; ví dụ: nếu chương trình có tới 8 con xúc xắc và tung ra con số có thể xảy ra nhất với 8 con xúc xắc, đầu ra sẽ là:

2
4
6

Chạy ví dụ

Trên 2 con xúc xắc, 7là tổng có thể xảy ra nhất. Hãy nói rằng các con số đã được 2và 3. Sau đó, bạn sẽ in 2.

Trên 4 con xúc xắc, 14là tổng có thể xảy ra nhất. Hãy nói rằng những con số cán là 3, 4, 2, và 5. Sau đó, tổng là 14, vì vậy chương trình sẽ chấm dứt ở đây.

Đầu ra cuối cùng trong trường hợp này là "2".

Quy tắc

• code-golf để giải pháp ngắn nhất trong byte thắng
• Áp dụng sơ hở tiêu chuẩn
• Các định nghĩa meta của tính ngẫu nhiên áp dụng
• Bạn có thể sử dụng các chức năng cũng như các chương trình

Python 2 , 70 byte

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

Hãy thử trực tuyến!

Mẹo nhỏ là tính tổng bằng cách nhập evalmột chuỗi trông giống như

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

với các nbản sao của biểu thức được nối. Các randrange(6)đầu ra một số ngẫu nhiên từ [0,1,2,3,4,5], được chuyển xuống 2.5để có trung bình 0. Khi tổng nếu 0, whileđiều kiện không thành công và vòng lặp chấm dứt.

Một thay thế sử dụng mapdài hơn 4 byte:

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

Tôi đã tìm thấy một loạt các biểu thức có độ dài bằng nhau cho một con súc sắc chuyển sang có nghĩa là không, nhưng không có biểu thức nào ngắn hơn

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

MATL , 13 byte

`@E6y&Yrs@7*-

Hãy thử trực tuyến!

Giải trình

`       % 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)

Thạch ,  19  14 byte

-5 byte với sự trợ giúp từ Leaky Nun (chuyển từ đếm lên sang đệ quy)

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

Một chương trình đầy đủ in các kết quả được phân tách bằng các dòng mới (một không gian thêm và dòng mới cũng được in và các lỗi chương trình ở cuối).

Hãy thử trực tuyến! - bất cứ khi nào 6 con xúc xắc bị vượt qua TIO sẽ giết chết điều này do sử dụng bộ nhớ, nhưng nó hoạt động trên nguyên tắc - cũng mất ~ 40 giây để làm như vậy.

Một phiên bản 15 byte thân thiện hơn, không mất nhiều thời gian hoặc đòi hỏi nhiều bộ nhớ có sẵn ở đây .

Làm sao?

Đệ quy cuộn thêm 2 viên xúc xắc cho đến khi tổng số các mặt được giảm 3,5 bằng 0, in số xúc xắc khi nó đi, khi đạt đến số 0, nó cố gắng sử dụng ký tự khoảng trắng gây ra lỗi loại.

‘‘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 byte

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

Giải trình

• randInt(1,6,N) tạo danh sách N số ngẫu nhiên từ 1 đến 6
• mean(randInt(1,6,N)-3.5 lấy trung bình của các cuộn giảm xuống 3,5
• While tiếp tục cho đến khi biểu thức trung bình bằng 0 (tổng có thể xảy ra nhất)

R , 49 byte

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

sample(6,n,T)tạo ncác mẫu ngẫu nhiên (giả) từ phạm vi 1:6có thay thế. Trừ 3,5 từ mỗi phần tử mang lại kết quả có sum0 (falsey) khi và chỉ khi đó là giá trị phổ biến nhất.

Hãy thử trực tuyến!

Bỏ qua các cuộn xúc xắc lẻ.

Java 8, 123 149 113 108 byte

()->{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);}}

Hoặc 107 byte nếu chúng ta sử dụng một Object nulltham số không sử dụng thay thế.

+26 byte cho một sửa lỗi, được chỉ ra chính xác bởi @Jules trong các bình luận.
-41 byte nhờ vào suy nghĩ tuyệt vời của @ OliverGrégoire !

Giải trình:

Hãy thử nó ở đây.

()->{                           // 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 byte

-2 byte nhờ Emigna

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

Hãy thử trực tuyến!

Giải trình

[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 byte

Một cải tiến 5 byte cho câu trả lời của Giuseppe .

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

(Ab) này sử dụng thực tế Flà một biến theo mặc định được gán cho FALSEép buộc 0và sau đó có thể được tăng lên, tiết kiệm cho chúng tôi nhu cầu khởi tạo biến đếm.

PHP , 75 byte

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

Hãy thử trực tuyến!

GolfScript , 41 byte

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

Hãy thử trực tuyến!

Toán học, 47 byte

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

-5 byte từ LLlAMnYP

05AB1E , 17 byte

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

Hãy thử trực tuyến!

Giải trình

[                   # 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

Mẻ, 109 byte

@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%

Khá khó chịu, randomlà một biến môi trường ma thuật, vì vậy nó chỉ được thay thế bằng một giá trị ngẫu nhiên trong quá trình mở rộng môi trường, điều này thường xảy ra trước khi vòng lặp for bắt đầu. calllàm cho nó xảy ra mỗi lần qua vòng lặp, nhưng sau đó bạn cần tăng gấp đôi các %dấu hiệu để ngăn chặn sự mở rộng xảy ra trước vòng lặp. Cuộc vui bắt đầu bởi vì chúng tôi muốn điều chỉnh kết quả bằng 6, yêu cầu một %dấu hiệu thực , giờ đây phải được nhân đôi hai lần. Kết quả là sáu %s liên tiếp .

JavaScript (ES2015), 75 78 byte

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

Xuất ra một chuỗi kết quả được phân tách bằng dòng mới

Chỉnh sửa: đã lưu một byte nhờ Shaggy, thêm 4 byte để bắt đầu chức năng ở 2

Giải trình

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 ký tự

$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 byte

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;}

Hãy thử trực tuyến!

Haskell 133 132 byte

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)

Tín dụng cho @Laikoni cho các đề xuất trong các ý kiến ​​dưới đây.

Octave 55 byte

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

Lấy cảm hứng từ câu trả lời của Andrewarchi. Nếu ai đó có bất kỳ con trỏ nào để rút ngắn nó, họ đều được chào đón.

Bình thường , 20 byte

K2WnsmhO6K*K3.5K=+K2

Hãy thử trực tuyến!

QBIC , 40 byte

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

Điều này thực sự rất nhiều những gì thách thức yêu cầu; dường như cách ngắn nhất để có được sự phân phối đúng

Giải trình

{          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 byte

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

Hãy thử trực tuyến!

JavaScript (ES6) - 69 ký tự

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())

Giải thích :

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

và:

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 byte

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));

vô dụng:

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));
}

Tôi có thể làm mà không cần Math.Int () nhưng thật không may trong 0,7 các hàm Random (). Next () có một lỗi trong đó tất cả chúng đều trả về gấp đôi thay vì ints. Nó đã được sửa nhưng chỉ sau khi câu hỏi này được đăng. Tôi sẽ không giành được bất cứ điều gì, nhưng hey, bằng chứng tốt đẹp của khái niệm.

Chỉnh sửa:

• đã loại bỏ không gian không cần thiết giữa việc sử dụng và "thời gian chạy" (-1 byte)

Chỉnh sửa2:

• đã xóa var r và tạo một Random mới khi cần (-4 byte)

• đã thay đổi i = 0, d = 0 thành i = d = 0 (-2 byte)

• tăng i sau khi kiểm tra (-1 byte)

Ruby , 52 byte

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

Giải trình

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

Hãy thử trực tuyến!

Javascript, 87 ký tự

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

Kiểm tra với console.logthay vì 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 byte

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)

Hoặc phiên bản dễ đọc hơn

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

Một phiên bản gian lận hơn cho 96 byte

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)

Điều này khá nhiều hoạt động tương tự như lần đầu tiên nhưng sử dụng lại các cuộn từ các cuộc gọi trước đó. Vì điều này tôi có thể loại bỏ vòng lặp for. Cả hai đều được thử nghiệm trong lua 5.2

Perl 6 , 48 byte

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

PHP, 51 byte

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