Problem

Zaczynając od n=2kości:

• Rzuć nkośćmi, przy czym każda liczba od 1 do 6 jest równie prawdopodobna na każdej kości.
• Sprawdź, czy ich suma jest równa najbardziej prawdopodobnej sumie nkości 3.5*n.
  • Jeśli są równe, zakończ.
  • W przeciwnym razie wydrukuj ni powtórz od początku z n+2kostkami

Twój kod nie musi dokładnie wykonywać tej procedury, ale powinien dać losowy wynik probabilistycznie równoważny, w oparciu o naszą definicję losowości .

Twój program powinien wypisać wszystkie liczby we własnej linii; na przykład, jeśli program uzyskał do 8 kości i rzucił najbardziej prawdopodobną liczbę za pomocą 8 kości, wynik byłby następujący:

2
4
6

Przykładowy bieg

Na 2 kościach 7jest najbardziej prawdopodobna suma. Powiedzmy, że wyrzucono liczby 2i 3. Następnie wydrukowałbyś 2.

Na 4 kościach 14jest najbardziej prawdopodobna suma. Powiedzmy, że numery były walcowane 3, 4, 2, i 5. Zatem suma jest 14, więc program zakończyłby się tutaj.

Ostateczne wyjście w tym przypadku to "2".

Zasady

• golf-code, więc najkrótsze rozwiązanie w bajtach wygrywa
• Obowiązują standardowe luki
• Definicja meta losowości dotyczy
• Możesz korzystać zarówno z funkcji, jak i programów

Python 2 , 70 bajtów

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

Wypróbuj online!

Sztuczka polega na obliczeniu sumy przez evalwprowadzenie łańcucha, który wygląda

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

z nkopiami wyrażenia połączonymi. Do randrange(6)wyjścia z liczbą losową [0,1,2,3,4,5], która jest przesunięta w dół przez 2.5mieć średnią 0. Gdy suma if 0, whilewarunek kończy się niepowodzeniem i pętla kończy się.

Alternatywne użycie mapbyło 4 bajty dłuższe:

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

Znalazłem kilka wyrażeń o takiej samej długości dla kości przesuniętej do zera, ale nie krótszej

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

MATL , 13 bajtów

`@E6y&Yrs@7*-

Wypróbuj online!

Wyjaśnienie

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

Galaretka ,  19  14 bajtów

-5 bajtów z pomocą Dziurawej Zakonnicy (przejście od zliczania do rekurencji)

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

Pełny program drukujący wyniki oddzielone znakami nowej linii (drukowana jest również dodatkowa spacja i znak nowej linii oraz błędy programu na końcu).

Wypróbuj online! - za każdym razem, gdy 6 kości zostanie przekroczonych, TIO zabija to z powodu zużycia pamięci, ale działa w zasadzie - zajmuje to również około 40 sekund.

Bardziej przyjazna wersja 15 bajt, który nie trwa tak długo albo wymagają tak dużo pamięci jest dostępny tutaj .

W jaki sposób?

Rekurencyjnie rzuca 2 dodatkowymi kośćmi, aż suma twarzy zmniejszonych o 3,5 wynosi zero, wypisując liczbę kostek w miarę ich przesuwania, gdy osiągnie zero, próbuje użyć znaku spacji, powodując błąd typu.

‘‘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 bajtów

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

Wyjaśnienie

• randInt(1,6,N) generuje listę N liczb losowych od 1 do 6
• mean(randInt(1,6,N)-3.5 zostaje obniżona średnia z rzutów o 3,5
• While trwa do momentu, aż średnie wyrażenie wyniesie zero (najbardziej prawdopodobna suma)

R , 49 bajtów

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

sample(6,n,T)generuje n(pseudo) losowe próbki z zakresu 1:6z zamiennikiem. Odejmowanie 3,5 od każdego elementu daje wynik, który sumwynosi 0 (falsey) wtedy i tylko wtedy, gdy jest to najczęstsza wartość.

Wypróbuj online!

Pomija rzuty nieparzystymi kośćmi.

Java 8, 123 149 113 108 bajtów

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

Lub 107 bajtów , jeśli używamy jak nieużywany parametr zamiast.Object null

+26 bajtów na usunięcie błędu, poprawnie wskazane przez @Jules w komentarzach.
-41 bajtów dzięki wspaniałemu myśleniu @ OliverGrégoire !

Wyjaśnienie:

Wypróbuj tutaj.

()->{                           // 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 bajtów

-2 bajty dzięki Emignie

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

Wypróbuj online!

Wyjaśnienie

[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 bajtów

5-bajtowa poprawa odpowiedzi Giuseppe .

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

To (ab) wykorzystuje fakt, że Fjest to zmienna domyślnie przypisana, do FALSEktórej wymusza się 0i może być następnie zwiększana, co oszczędza nam potrzeby inicjalizacji zmiennej przeciwnej.

PHP , 75 bajtów

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

Wypróbuj online!

GolfScript , 41 bajtów

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

Wypróbuj online!

Mathematica, 47 bajtów

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

-5 bajtów z LLlAMnYP

05AB1E , 17 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Partia, 109 bajtów

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

Raczej denerwująco randomjest magiczną zmienną środowiskową, więc zastępuje ją ona losową wartością podczas ekspansji środowiska, co zwykle dzieje się przed uruchomieniem pętli for. callsprawia, że ​​dzieje się to za każdym razem przez pętlę, ale następnie należy podwoić %znaki, aby zapobiec rozszerzeniu przed pętlą. Zabawa zaczyna się, ponieważ chcemy modulować wynik o 6, co wymaga prawdziwego %znaku, który teraz należy podwoić dwukrotnie. Wynik to sześć kolejnych %sekund.

JavaScript (ES2015), 75 78 bajtów

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

Wysyła ciąg wyników oddzielonych znakami nowej linii

Edycja: zapisano bajt dzięki Shaggy, dodano 4 bajty, aby uruchomić funkcję o 2

Wyjaśnienie

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 znaków

$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 bajtów

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

Wypróbuj online!

Haskell 133 132 bajty

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)

Podziękowania dla @Laikoni za sugestie w komentarzach poniżej.

Oktawa 55 bajtów

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

Zainspirowany odpowiedzią Andrewarchiego. Jeśli ktoś ma jakieś wskazówki, aby go nawet skrócić, są mile widziane.

Pyth , 20 bajtów

K2WnsmhO6K*K3.5K=+K2

Wypróbuj online!

QBIC , 40 bajtów

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

Ta postawa dosłownie robi to, o co prosi wyzwanie; wydaje się najkrótszą drogą do prawidłowej dystrybucji.

Wyjaśnienie

{          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 bajtów

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

Wypróbuj online!

JavaScript (ES6) - 69 znaków

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

Objaśnienie :

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

i:

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.

Oblicz2 0,7, 119 118 111 bajtów

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

bez golfa:

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

Mógłbym obejść się bez Math.Int (), ale niestety w 0.7 funkcje Random (). Next () mają błąd, w którym wszystkie zwracają podwójne zamiast ints. Zostało to naprawione, ale dopiero po opublikowaniu tego pytania. Nic nie wygram, ale hej, niezły dowód koncepcji.

Edytować:

• usunięto niepotrzebne miejsce między używaniem a „środowiskiem wykonawczym” (-1 bajt)

Edycja2:

• usunięto var r i utwórz nowy Losowo tam, gdzie jest potrzebny (-4 bajty)

• zmieniono i = 0, d = 0 na i = d = 0 (-2 bajty)

• inkrementowane i po sprawdzeniu (-1 bajt)

Ruby , 52 bajty

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

Wyjaśnienie

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

Wypróbuj online!

JavaScript, 87 znaków

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

Test ze console.logzamiast 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 bajty

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)

Lub bardziej czytelna wersja

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

Bardziej cheatyczna wersja na 96 bajtów

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)

To działa prawie tak samo jak pierwsze, ale ponownie wykorzystuje rzutki z wcześniejszych połączeń. Z tego powodu mogę usunąć pętlę for. Oba są testowane w lua 5.2

Perl 6 , 48 bajtów

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

PHP, 51 bajtów

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