Problema

A partire dai n=2dadi:

• Lancia i ndadi, con ogni numero da 1 a 6 ugualmente probabile su ogni dado.
• Controlla se la loro somma è uguale alla somma più probabile per i ndadi, cioè 3.5*n.
  • Se sono uguali, termina.
  • Altrimenti, stampa ne ripeti dall'inizio con i n+2dadi

Il codice non deve eseguire esattamente questa procedura, ma dovrebbe fornire un output casuale probabilisticamente equivalente ad esso, in base alla nostra definizione di casualità .

Il tuo programma dovrebbe generare tutti i numeri sulla propria riga; per esempio, se il programma ottenesse fino a 8 dadi e tirasse il numero più probabile con 8 dadi, l'output sarebbe:

2
4
6

Esempio di esecuzione

Su 2 dadi, 7è la somma più probabile. Diciamo che i numeri ottenuti erano 2e 3. Quindi, si stampa 2.

Su 4 dadi, 14è la somma più probabile. Diciamo che i numeri erano arrotolati 3, 4, 2, e 5. Quindi, la somma è 14, quindi il programma terminerebbe qui.

L'output finale in questo caso è "2".

Regole

• vince la code-golf quindi la soluzione più breve in byte
• Si applicano scappatoie standard
• Si applica la meta definizione di casualità
• È possibile utilizzare funzioni e programmi

Python 2 , 70 byte

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

Provalo online!

Il trucco è calcolare la somma evalinging una stringa che assomiglia

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

con ncopie dell'espressione concatenate. Le randrange(6)uscite un numero casuale da [0,1,2,3,4,5], che viene spostata dalla 2.5abbiano media 0. Quando la somma se 0, la whilecondizione fallisce e il ciclo termina.

Un'alternativa usando mapera 4 byte più lunghi:

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

Ho trovato un sacco di espressioni di uguale lunghezza per un dado spostato a zero, ma nessuna più breve

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

MATL , 13 byte

`@E6y&Yrs@7*-

Provalo online!

Spiegazione

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

Gelatina ,  19  14 byte

-5 byte con l'aiuto di Leaky Nun (passando dal conteggio alla ricorsione)

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

Un programma completo che stampa i risultati separati da nuove righe (vengono stampati anche uno spazio extra e una nuova riga e gli errori del programma alla fine).

Provalo online! - ogni volta che vengono superati 6 dadi TIO lo uccide a causa dell'utilizzo della memoria, ma funziona in linea di principio - ci vogliono anche ~ 40 secondi per farlo.

È disponibile una versione più amichevole di 15 byte che non richiede così tanto tempo o richiede così tanta memoria qui .

Come?

Lancia in modo ricorsivo altri 2 dadi fino a quando la somma delle facce ridotta di 3,5 è zero, stampando il numero di dadi mentre procede, quando viene raggiunto lo zero tenta di usare un carattere spazio causando un errore di tipo.

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

Spiegazione

• randInt(1,6,N) genera un elenco di N numeri casuali da 1 a 6
• mean(randInt(1,6,N)-3.5 ottiene la media dei tiri spostati verso il basso di 3,5
• While continua fino a quando l'espressione media è uguale a zero (la somma più probabile)

R , 49 byte

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

sample(6,n,T) genera n campioni (pseudo) casuali dall'intervallo 1:6con la sostituzione. Sottraendo 3,5 da ciascun elemento si ottiene un risultato il cui valore sumè 0 (falso) se e solo se è il valore più comune.

Provalo online!

Salta i tiri di dado dispari.

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

O 107 byte se utilizziamo un Object nullparametro come inutilizzato .

+26 byte per una correzione di bug, sottolineata correttamente da @Jules nei commenti.
-41 byte grazie al grande pensiero di @ OliverGrégoire !

Spiegazione:

Provalo qui.

()->{                           // 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 grazie a Emigna

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

Provalo online!

Spiegazione

[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

Un miglioramento di 5 byte sulla risposta di Giuseppe .

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

Questo (ab) usa il fatto che Fè una variabile di default assegnata alla FALSEquale si costringe 0e può quindi essere incrementata, risparmiandoci la necessità di inizializzare una variabile contatore.

PHP , 75 byte

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

Provalo online!

GolfScript , 41 byte

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

Provalo online!

Mathematica, 47 byte

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

-5 byte da LLlAMnYP

05AB1E , 17 byte

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

Provalo online!

Spiegazione

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

Lotto, 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%

Piuttosto fastidiosamente, randomè una variabile d'ambiente magica, quindi viene sostituita con un valore casuale durante l'espansione dell'ambiente, che di solito accade prima che inizi il ciclo for. calllo fa accadere ogni volta attraverso il ciclo, ma è necessario raddoppiare i %segni per impedire l'espansione prima del ciclo. Il divertimento inizia perché vogliamo modulare il risultato per 6, che richiede un %segno reale , che ora deve essere raddoppiato due volte. Il risultato è sei %s consecutivi .

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)

Emette una serie di risultati separati da newline

Modifica: salvato un byte grazie a Shaggy, aggiunti 4 byte per avviare la funzione da 2

Spiegazione

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 personaggi

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

Provalo online!

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)

Ringraziamo @Laikoni per i suggerimenti nei commenti qui sotto.

Ottava 55 byte

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

Ispirato dalla risposta di Andrewarchi. Se qualcuno ha qualche suggerimento per accorciarlo, sono i benvenuti.

Pyth , 20 byte

K2WnsmhO6K*K3.5K=+K2

Provalo online!

QBIC , 40 byte

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

Questo abbastanza letteralmente fa ciò che la sfida richiede; sembra il modo più breve per ottenere la distribuzione corretta.

Spiegazione

{          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

Provalo online!

JavaScript (ES6) - 69 caratteri

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

Spiegazione :

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

e:

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

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

Potrei fare a meno di Math.Int () ma sfortunatamente in 0.7 le funzioni Random (). Next () hanno un bug in cui tutti restituiscono double invece di ints. È stato risolto ma solo dopo che questa domanda è stata pubblicata. Non vincerò nulla, ma hey, bella dimostrazione del concetto.

Modificare:

• rimosso lo spazio non necessario tra l'utilizzo e "runtime" (-1 byte)

Edit2:

• rimosso var r e crea un nuovo casuale dove è necessario (-4 byte)

• modificato i = 0, d = 0 in i = d = 0 (-2 byte)

• i incrementato dopo il controllo (-1 byte)

Rubino , 52 byte

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

Spiegazione

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

Provalo online!

Javascript, 87 caratteri

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

Prova con console.loginvece di 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)

O la versione più leggibile

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

Una versione più economica per 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)

Funziona praticamente come il primo ma riutilizza i tiri delle chiamate precedenti. Per questo motivo posso rimuovere il ciclo for. Entrambi sono testati in 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;}