문제

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"입니다.

규칙

• 바이트 단위의 코드 골프 너무 짧은 솔루션 승리
• 표준 허점 적용
• 무작위성 의 메타 정의가 적용됩니다
• 프로그램뿐만 아니라 기능도 사용할 수 있습니다

파이썬 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. 되면 합 만약 0상기 while조건이 실패하고, 루프 종료한다.

사용하는 대안 map은 4 바이트 더 길었습니다.

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

다이에 대한 동일한 길이의 표현이 0을 의미하도록 이동했지만 더 짧지 않은 것을 발견했습니다.

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 바이트 버전이 여기에 있습니다 .

방법?

각각 3.5로 줄어든면의 합이 0이 될 때까지 주사위 2 개를 재귀 적으로 굴립니다. 0에 도달 할 때 주사위 수를 인쇄합니다.

‘‘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 평균 표현식이 0이 될 때까지 계속됩니다 (가장 가능한 합계)

R , 49 바이트

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

sample(6,n,T)대체 n범위에서 (의사) 임의 샘플을 생성 1:6합니다. 각 요소에서 3.5를 빼면 sum가장 일반적인 값인 경우에만 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

주석에서 @Jules 가 올바르게 지적한 버그 수정의 경우 +26 바이트 @ OliverGrégoire 의 위대한 생각
덕분에 -41 바이트 !

설명:

여기에서 시도하십시오.

()->{                           // 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 바이트

Emigna 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

수학, 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 씩 모듈로 만들고 싶기 때문에 재미가 시작됩니다. 실제 %부호 가 필요합니다. 이는 이제 두 배가되어야합니다. 결과는 6 연속 %입니다.

자바 스크립트 (ES2015), 75 78 바이트

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

줄 바꿈으로 구분 된 결과 문자열을 출력합니다.

편집 : Shaggy 덕분에 바이트를 저장하고 2에서 기능을 시작하기 위해 4 바이트를 추가했습니다.

설명

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 바이트

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

온라인으로 사용해보십시오!

하스켈 133 132 바이트

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)

아래 의견의 제안에 대해서는 @Laikoni에게 감사드립니다.

옥타브 55 바이트

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

Andrewarchi의 답변에서 영감을 얻었습니다. 누군가가 그것을 단축 할 수있는 포인터가 있다면 그들은 환영합니다.

Pyth , 20 바이트

K2WnsmhO6K*K3.5K=+K2

온라인으로 사용해보십시오!

QBIC , 40 바이트

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

이것은 문자 그대로 도전이 요구하는 것을 수행합니다. 배포를 올바르게하는 가장 짧은 방법 인 것 같습니다.

설명

{          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 (레지나) , 78 바이트

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

온라인으로 사용해보십시오!

JavaScript (ES6)-69 자

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

설명 :

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

과:

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 바이트

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

언 골프 :

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

Math.Int () 없이는 할 수 있지만 불행히도 0.7에서는 Random (). Next () 함수에 int 대신 double을 반환하는 버그가 있습니다. 이 질문은 게시 된 후에 수정되었습니다. 나는 아무것도 이길 수 없지만 좋은 개념 증명입니다.

편집하다:

• 사용과 "런타임"사이의 불필요한 공간을 제거했습니다 (-1 바이트).

편집 2 :

• var r을 제거하고 필요한 곳에 새로운 랜덤을 생성하십시오 (-4 바이트)

• i = 0, d = 0을 i = d = 0 (-2 바이트)으로 변경

• 확인 후 i를 증분 (-1 바이트)

루비 , 52 바이트

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

설명

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

온라인으로 사용해보십시오!

자바 스크립트, 87 자

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

console.log대신에 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')

루아, 102 바이트

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)

또는 더 읽기 쉬운 버전

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

96 바이트를위한 더 매력적인 버전

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)

이것은 첫 번째와 거의 동일하지만 이전 통화의 롤을 재사용합니다. 이 때문에 for 루프를 제거 할 수 있습니다. 둘 다 루아 5.2에서 테스트되었습니다.

펄 6 , 48 바이트

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

PHP, 51 바이트

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