Problem

Ausgehend von n=2Würfeln:

• Wirf nWürfel, wobei jede Zahl 1 bis 6 auf jedem Würfel gleich wahrscheinlich ist.
• Überprüfen Sie, ob ihre Summe der wahrscheinlichsten Summe für nWürfel entspricht 3.5*n.
  • Wenn sie gleich sind, kündigen Sie.
  • Andernfalls drucken nund von Anfang an mit n+2Würfeln wiederholen

Ihr Code muss diese Prozedur nicht genau ausführen, sollte aber eine zufällige Ausgabe liefern, die auf der Grundlage unserer Definition der Zufälligkeit wahrscheinlich äquivalent ist .

Ihr Programm sollte alle Zahlen in einer eigenen Zeile ausgeben. Wenn das Programm beispielsweise bis zu 8 Würfel hat und die wahrscheinlichste Zahl mit 8 Würfeln gewürfelt hat, wäre die Ausgabe:

2
4
6

Beispiellauf

Bei 2 Würfeln 7ist dies die wahrscheinlichste Summe. Nehmen wir an, die Zahlen waren 2und 3. Dann würden Sie drucken 2.

Bei 4 Würfeln 14ist dies die wahrscheinlichste Summe. Lassen Sie uns sagen , die Zahlen gerollt waren 3, 4, 2, und 5. Ist dann die Summe 14, so würde das Programm hier enden.

Die endgültige Ausgabe in diesem Fall ist "2".

Regeln

• Code-Golf, so dass die kürzeste Lösung in Bytes gewinnt
• Es gelten Standardlücken
• Die Meta - Definition der Zufälligkeit gilt
• Sie können sowohl Funktionen als auch Programme verwenden

Python 2 , 70 Bytes

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

Probieren Sie es online!

Der Trick besteht darin, die Summe zu berechnen, indem evaleine Zeichenfolge wie folgt erstellt wird

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

mit nKopien des Ausdrucks verkettet. Der randrange(6)gibt eine Zufallszahl aus [0,1,2,3,4,5], die um den 2.5Durchschnitt von heruntergeschoben wird 0. Wenn die Summe if ist 0, whileschlägt die Bedingung fehl und die Schleife wird beendet.

Eine alternative Verwendung mapwar 4 Bytes länger:

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

Ich habe eine Reihe gleichlanger Ausdrücke für einen Würfel gefunden, die auf Null verschoben, aber nicht kürzer sind

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

MATL , 13 Bytes

`@E6y&Yrs@7*-

Probieren Sie es online!

Erläuterung

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

Jelly ,  19  14 Bytes

-5 Bytes mit Hilfe von Leaky Nun (Übergang von der Zählung zur Rekursion)

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

Ein vollständiges Programm druckt die Ergebnisse durch Zeilenumbrüche getrennt aus (ein zusätzliches Leerzeichen und eine neue Zeile werden ebenfalls gedruckt, und die Programmfehler am Ende).

Probieren Sie es online! - Jedes Mal, wenn 6 Würfel überschritten werden, tötet TIO dies aufgrund des Speicherverbrauchs, aber es funktioniert im Prinzip - es dauert auch ~ 40s, um dies zu tun.

Eine freundlichere 15-Byte-Version, die nicht so lange dauert oder so viel Speicher benötigt, ist hier verfügbar .

Wie?

Wirft rekursiv 2 weitere Würfel, bis die Summe der jeweils um 3,5 reduzierten Flächen Null ist. Dabei wird die Anzahl der Würfel gedruckt. Wenn die Null erreicht ist, wird versucht, ein Leerzeichen zu verwenden, das einen Tippfehler verursacht.

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

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

Erläuterung

• randInt(1,6,N) generiert eine Liste von N Zufallszahlen von 1 bis 6
• mean(randInt(1,6,N)-3.5 Ruft den Durchschnitt der Rollen um 3,5 nach unten verschoben
• While setzt sich fort, bis der durchschnittliche Ausdruck gleich Null ist (die wahrscheinlichste Summe)

R , 49 Bytes

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

sample(6,n,T)generiert n(Pseudo-) Zufallsstichproben aus dem Bereich 1:6mit Ersetzung. sumWenn Sie von jedem Element 3,5 subtrahieren, erhalten Sie ein Ergebnis, das genau dann 0 (falsch) ist, wenn es der häufigste Wert ist.

Probieren Sie es online!

Überspringt die ungeraden Würfelwürfe.

Java 8, 123 149 113 108 Bytes

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

Oder 107 Bytes, wenn wir stattdessen einen Object nullnicht verwendeten Parameter verwenden.

+26 Bytes für einen Bugfix, der von @Jules in den Kommentaren korrekt angegeben wurde.
-41 Bytes dank @ OliverGrégoires großartigem Denken!

Erläuterung:

Probieren Sie es hier aus.

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

-2 Bytes dank Emigna

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

Probieren Sie es online!

Erläuterung

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

Eine 5-Byte-Verbesserung gegenüber Giuseppes Antwort .

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

Dies (ab) verwendet die Tatsache, dass Fstandardmäßig eine Variable zugewiesen ist, FALSEdie erzwungen wird 0und dann inkrementiert werden kann, so dass wir keine Zählervariable initialisieren müssen.

PHP , 75 Bytes

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

Probieren Sie es online!

GolfScript , 41 Bytes

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

Probieren Sie es online!

Mathematica, 47 Bytes

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

-5 Bytes von LLlAMnYP

05AB1E , 17 Bytes

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

Probieren Sie es online!

Erläuterung

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

Batch, 109 Bytes

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

Ziemlich ärgerlich randomist, dass eine magische Umgebungsvariable nur während der Umgebungserweiterung durch einen zufälligen Wert ersetzt wird, was normalerweise vor dem Start der for-Schleife geschieht. callmacht es jedes Mal durch die Schleife geschehen, aber dann müssen Sie die %Zeichen verdoppeln , um zu verhindern, dass die Erweiterung vor der Schleife geschieht. Der Spaß beginnt, weil wir das Ergebnis mit 6 modulieren wollen, was ein echtes %Vorzeichen erfordert , das nun zweimal verdoppelt werden muss. Das Ergebnis sind sechs aufeinanderfolgende %s.

JavaScript (ES2015), 75 bis 78 Byte

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

Gibt eine durch Zeilenumbrüche getrennte Folge von Ergebnissen aus

Bearbeiten: Speichert ein Byte dank Shaggy, fügt 4 Bytes hinzu, um die Funktion bei 2 zu starten

Erläuterung

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 Zeichen

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

Probieren Sie es 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)

Dank an @Laikoni für die Vorschläge in den Kommentaren unten.

Oktave 55 Bytes

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

Inspiriert von Andrewarchis Antwort. Wenn jemand irgendwelche Hinweise hat, um sie zu verkürzen, ist er willkommen.

Pyth , 20 Bytes

K2WnsmhO6K*K3.5K=+K2

Probieren Sie es online!

QBIC , 40 Bytes

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

Das macht buchstäblich das, was die Herausforderung verlangt; scheint der kürzeste Weg zu sein, um die Verteilung richtig zu machen.

Erläuterung

{          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

Probieren Sie es online!

JavaScript (ES6) - 69 Zeichen

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

Erklärung :

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

und:

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

Ich könnte auf die Math.Int () verzichten, aber leider haben die Random (). Next () -Funktionen in 0.7 einen Fehler, bei dem alle statt ints double zurückgeben. Es wurde behoben, aber erst nachdem diese Frage gestellt wurde. Ich werde nichts gewinnen, aber hey, schöner Proof of Concept.

Bearbeiten:

• unnötiger Platz zwischen using und "runtime" (-1 Byte) entfernt

Edit2:

• entferne var r und erstelle ein neues Random wo es gebraucht wird (-4 byte)

• i = 0, d = 0 in i = d = 0 (-2 Byte) geändert

• inkrementiert i nach Prüfung (-1 Byte)

Ruby , 52 Bytes

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

Erläuterung

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

Probieren Sie es online!

Javascript, 87 Zeichen

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

Testen Sie mit console.loganstelle von 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)

Oder die besser lesbare 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

Eine betrügerische Version für 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)

Dies funktioniert so ziemlich genauso wie das erste, verwendet jedoch die Rollen früherer Aufrufe wieder. Aus diesem Grund kann ich die for-Schleife entfernen. Beide sind in lua 5.2 getestet

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