Angenommen, Sie haben zwei sechsseitige Würfel. Wirf das Paar 100 Mal und berechne die Summe jedes Paares. Geben Sie aus, wie oft jede Summe aufgetreten ist. Wenn eine Summe nie gerollt wurde, müssen Sie eine Null oder eine Methode angeben, um zu identifizieren, dass diese bestimmte Summe nie gerollt wurde.

Beispielausgabe: [3, 3, 9, 11, 15, 15, 11, 15, 7, 8, 3]

Die Häufigkeit, mit der eine Summe gewürfelt wurde, ist im Summenindex 2 angegeben

In diesem Beispiel wurde eine Summe von zwei 3-mal gewürfelt ([2-2]), eine Summe von drei 3-mal gewürfelt ([3-2]), eine Summe von vier 9-mal gewürfelt ([4-2]) und so weiter auf. Es spielt keine Rolle, ob die einzelnen Würfelwürfe zu einer Summe führen (5 und 2 werden als die gleiche Summe wie 6 und 1 gezählt).

"Hässliche" Ausgaben sind in Ordnung (viele nachgestellte Nullen, zusätzliche Ausgaben, seltsame Darstellungsweisen von Daten usw.), solange Sie erklären, wie die Daten gelesen werden sollen.

Jelly , 13 12 Bytes

³Ḥ6ẋX€+2/ṢŒr

Eine Niladische Verbindung. Das Ausgabeformat ist eine Liste mit Listen von[value, count] .

(Null würfelt bedeutet, dass kein solcher Eintrag in der Ausgabe vorhanden ist - z. B. würde eine Ausgabe von [[6, 12], [7, 74], [8, 14]]angeben, dass nur Summen von sechs, sieben und acht gewürfelt wurden.)

Probieren Sie es online!

Wie?

³Ḥ6ẋX€+2/ṢŒr - Main link: no arguments
³            - 100
 Ḥ           - double = 200
  6          - 6
   ẋ         - repeat -> [6,6,6...,6], length 200
    X€       - random integer from [1,z] for €ach (where z=6 every time)
       2/    - pairwise reduce with:
      +      -   addition (i.e. add up each two)
         Ṣ   - sort
          Œr - run-length encode (list of [value, length] for each run of equal values)

Python 2 , 84 77 76 Bytes

-7 Bytes dank @JonathanAllan
-1 Bytes dank @FelipeNardiBatista

from random import*
a=[0]*13
exec'a[%s]+=1;'%('+randint(1,6)'*2)*100
print a

Probieren Sie es online!

Der Ausgang hat zwei führende Nullen

05AB1E , 21 19 Bytes

-2 Bytes dank @Emigna

TÝÌтF6Lã.RO¸ì}{γ€g<

Probieren Sie es online!

TÝÌтF6Lã.RO¸ì}{γ€g<
TÝÌ                   Range from 2 to 12
   тF                 100 times do:
     6L                 Range from 1 to 6
       ã                Cartesian product (creates all possible pairs of 1 and 6)
        .RO             Choose random pair and sum
           ¸ì           Prepend result to initial list
             }        end loop
              {γ€g<   Sort, split on consecutive elements, count and decrement

Mathematica, 50 Bytes

r:=RandomInteger@5
Last/@Tally@Sort@Table[r+r,100]

Einfache Implementierung. Wenn eine Summe niemals erreicht wird, 0wird sie nicht in der Liste aufgeführt.

MATL , 17 Bytes

6H100I$Yrs!11:Q=s

Die Ausgabe ist eine Liste von 11 Zahlen (von denen einige möglicherweise 0 sind), die durch Leerzeichen getrennt sind und die Anzahl der Male für jedes Paar von 2 bis 12 angeben.

Probieren Sie es online!

Zum Vergleich kann die theoretische durchschnittliche Häufigkeit, mit der jedes Paar durchschnittlich auftritt, wie folgt berechnet werden 6:gtY+36/100* .

If the number of rolls is increased the obtained values approach the theorerical ones. See for example the obtained and theoretical values with 10000 rolls.

CJam, 18 20 bytes

100{;6mr6mr+))}%$e``

Probieren Sie es online!

Perl 6 , 30 Bytes

bag [Z+] (^6).pick xx 100 xx 2

(^6).pickist eine Zufallszahl von null bis fünf. xx 100erstellt eine 100-Elemente-Liste solcher Zahlen. xx 2erzeugt zwei solcher Listen. [Z+]Zippt diese beiden Listen mit Addition, wodurch eine Liste mit 100 Elementen mit zwei Würfeln erstellt wird. Zum Schluss bagpackt man diese Liste in eine Tasche, die eine Sammlung mit einer Vielzahl ist. Beispiel für eine REPL-Ausgabe:

bag(1(4), 9(4), 0(4), 4(14), 5(18), 3(9), 10(2), 6(19), 7(13), 2(3), 8(10))

Das bedeutet, dass 1, 9 und 0 jeweils viermal, viermal vierzehnmal usw. vorkamen. Da die "Würfel" in diesem Code eine Zahl von 0 bis 5 ergeben, addieren Sie zwei zu jeder dieser Zahlen, um den Würfeln ein Paar zu geben Standardwürfel 1-6 würden produzieren.

R , 45 37 Bytes

-7 Bytes dank Jarko Dubbledam

s=sample;table(s(6,100,T)+s(6,100,T))

Gibt ein Tabellenobjekt mit Elementen und deren Anzahl zurück. Schließt alle Werte aus, die nicht aufgetreten sind.

Probieren Sie es online!

alte Version:

rle(sort(colSums(matrix(sample(6,200,T),2))))

sample(6,200,T)200-mal 1:6abtasten mit Ersetzen, dann wird eine Matrix mit 2 Zeilen erstellt, die Spalten summiert, dann in aufsteigender Reihenfolge sortiert und die Länge der Läufe berechnet. Lässt alle nicht erreichten Würfelsummen aus.

Gibt ein rleObjekt zurück, das standardmäßig im folgenden Format gedruckt wird:

Run Length Encoding
  lengths: int [1:11] 5 6 8 12 12 20 12 11 4 7 ...
  values : num [1:11] 2 3 4 5 6 7 8 9 10 11 ...

Wo lengthssind die Zählimpulse und wo sind valuesdie Würfelsummen?

TIO Link

PHP, 53 Bytes

druckt ein assoziatives Array. Der Schlüssel ist das Ergebnis von zwei Würfeln und der Wert ist die Anzahl dieser Ergebnisse

for(;$i++<100;)$r[rand(1,6)+rand(1,6)]++;print_r($r);

Probieren Sie es online!

JavaScript (ES6), 72 Byte

Da eine "hässliche" Ausgabe zulässig ist, wird im Folgenden ein Array ausgegeben, das angibt, wie oft jede Punktzahl von 2 bis 12 gewürfelt wurde, wobei zusätzliche 89 Elemente auf 0 gesetzt werden.

_=>(a=Array(100).fill(0)).map(_=>a[g()+g()]++,g=_=>Math.random()*6|0)&&a

f=
_=>(a=Array(100).fill(0)).map(_=>a[g()+g()]++,g=_=>Math.random()*6|0)&&a
o.innerText=f()

<pre id=o>

SILOS , 99 Bytes

i=100
lbla
x=rand*6+rand*6
a=get x
a+1
set x a
i-1
if i a
lblb
c=get b
printInt c
b+1
d=11-b
if d b

Probieren Sie es online!

Wirft die Würfel und legt sie an den ersten 11 Stellen des Haufens ab. Anschließend durchläuft er den Haufen und druckt jeden Zähler. Dies ist eine der ersten aufgezeichneten Verwendungen des Schlüsselworts rand in Kombination mit einem Zuweisungsoperator.

Es ist erwähnenswert, dass einige Änderungen vorgenommen werden können, um ein Histogramm der Rollen auszugeben.

Leider muss es vom Offline-Interpreter ausgeführt werden .

i=4000
lbla
x=rand*6+rand*6
a=get x
a+1
set x a
i-1
if i a
canvas 1100 1000 Output
lblb
c=get b
printInt c
d=c*1
y=1000-d
x=b*100
newObj 0 100 d
moveObj b x y
b+1
d=11-b
if d b
wait 10000

Elixier, 157 118 Bytes

l=&Enum.random(1..&1)
p=fn(o,s)->y=l.(6)+l.(6)
s=List.update_at(s,y,&(&1+1))
if Enum.sum(s)<100 do s=o.(o,s) end
s end

Versuchte etwas schwerer als Gelee.

Erläuterung:

1. Definieren Sie eine Funktion, die eine Zufallszahl zwischen 1 und einschließlich 6 zurückgibt.
2. Definieren Sie die Funktion anonym und lassen Sie y die Variable mit der Rollsumme.
3. Aktualisieren Sie die entsprechende Stelle in der Liste, indem Sie 1 hinzufügen.
4. Wenn wir 100 Rollen haben, kündigen Sie. Rufen Sie sich andernfalls erneut an und übergeben Sie sich und die aktualisierte Liste.
5. Gibt das aktualisierte Array zurück.

Sollte gerne genannt werden p.(p,[0,0,0,0,0,0,0,0,0,0,0,0,0]). Es wird eine Warnung ausgegeben, aber es wird das gewünschte Array mit 13 Elementen zurückgegeben, die ersten 2 sollten ignoriert werden.

Java 8, 104 Bytes

Ein Lambda, das eine int[]der Frequenzen zurückgibt. Zuweisen zu Supplier<int[]>.

()->{int o[]=new int[11],i=0;while(i++<100)o[(int)(Math.random()*6)+(int)(Math.random()*6)]++;return o;}

Probieren Sie es online

Ungolfed Lambda

() -> {
    int
        o[] = new int[11],
        i = 0
    ;
    while (i++ < 100)
        o[(int) (Math.random() * 6) + (int) (Math.random() * 6)]++;
    return o;
}

q / kdb +, 31 28 25 Bytes

Lösung:

sum!:[11]=/:sum(2#100)?'6

Beispiel:

q)sum!:[11]=/:sum(2#100)?'6
1 3 5 11 16 21 16 9 8 9 1i

Erläuterung:

Wirf einen Würfel 100?6, wirf noch einmal einen Würfel und addiere die Vektoren. Dann sehen Sie, wo jedes Ergebnis dem Bereich 0..10 entspricht, und fassen Sie dann alle Wahrheiten in jeder Liste zusammen:

sum til[11]=/:sum(2#100)?'6 / ungolfed solution
                 (2#100)    / 2 take 100, gives list (100;100)
                        ?'6 / performs rand on each left-each right, so 100 & 6, 100 & 6
              sum           / add the lists together
    til[11]                 / the range 0..10
           =/:              / apply 'equals?' to each right on left list
sum                         / sum up the results, e.g. how many 1s, 2s, 3s.. 12s

Anmerkungen:

"Golfen" tauscht hauptsächlich qStichwörter gegen kÄquivalente aus, nämlich eachund til.

QBIC , 45 Bytes

[100|h=_r1,6|+_r1,6|-2┘g(h)=g(h)+1][0,z|?g(b)

Erläuterung:

[100|         FOR a = 1 to 100
h=_r1,6|       set h to a random value between 1-6
 +_r1,6|       + another rnd(1,6) (2, 3 ... 11, 12)
 -2            - 2 (index: 0 ... 10
┘             Syntactic linebreak
g(h)          When using array parenthesis on an undefined array,
              it is interpreted as an array with 10 indexes of all zeroes.           
    =         Of array g, set the value of index h (0 ... 11)
      g(h)+1  to one higher (all indices start out as 0)
              Note that we need to track 11 values. Fortunately, QBasic'set
              empty, 10-sized array has 11 indices, because of base 0 / base 1 ambiguity.
]             NEXT set of dice
[0,z|         FOR b = 0 to 10
?g(b)           PRINT the tracker array

APL, 14 Bytes

,∘≢⌸+/?100 2⍴6

Stellt Daten als Tabelle dar, wobei die linke Spalte die Summe und die rechte die Anzahl der Vorkommen darstellt.

Erklärt

        100 2⍴6  ⍝ create an 2×100 array of 6
       ?         ⍝ roll for each cell from 1 to 6
     +/          ⍝ sum every row
   ⌸            ⍝ for every unique sum
,∘≢              ⍝ get the sum and the number of indexes

Vorherigen Post:

APL, 36 31 Bytes

5 Bytes gespart dank @ Adám

(11⍴⍉⌽f)[⍋11⍴⍉f←,∘≢⌸+/?100 2⍴6]

Erläuterung

f←,∘≢⌸+/?100 2⍴6
          100 2⍴6    ⍝ create an 2×100 array of 6
         ?           ⍝ roll for each cell from 1 to 6
       +/            ⍝ sum every row
     ⌸              ⍝ for every unique sum
  ,∘≢                ⍝ get the sum and the number of indexes

(11⍴⍉⌽f)[⍋11⍴⍉f]  ⍝ ⍋x returns the indexes of the sorted x in the current x  
                     ⍝ x[y] find the yth elements of x
                     ⍝ x[⍋y] reorders x the same way that would be required to sort y

            11⍴⍉f   ⍝ the column of sums - see below
 11⍴⍉⌽f            ⍝ the column of counts - see below

Wie 11⍴⍉⌽ffunktioniert das

⍝ ⌽ - Reverses the array
⍝ ⍉ - Transposes the array

  ⍝   f
 9 14   ⍝ Sum - Occurences
 4  9
 7 17
 8 18
 6 15
 5  7
10  3
11  5
 3  6
 2  2
12  4

  ⍝   ⍉f
 9 4  7  8  6 5 10 11 3 2 12  ⍝ Sum
14 9 17 18 15 7  3  5 6 2  4  ⍝ Occurences

  ⍝   ⍉⌽f
14 9 17 18 15 7  3  5 6 2  4  ⍝ Occurences
 9 4  7  8  6 5 10 11 3 2 12  ⍝ Sum

> <> 93 Bytes

00[0[v
v 1\v/4
v 2xxx5
v 3/^\6
>l2(?^+]laa*=?v0[
  /&1+&\ v1&0]<
=?/ :?!\}>:@@:@
oa&0n&}< ^+1

Probieren Sie es online aus oder schauen Sie es sich auf dem Fischspielplatz an !

Das hässliche Ausgabeformat ist eine Folge von Zahlen, die durch Zeilenumbrüche getrennt sind n- te Zahl wie oft die Summe n war. Es ist hässlich, weil es für alle positiven ganzen Zahlen n für immer gedruckt wird , obwohl die meisten Zeilen 0 sind. ( Die TIO-Verbindung wird so geändert, dass sie nach n stoppt = 12 auf Kosten von 5 Byte beendet wird.)

Der Fischspielplatz ist ziemlich langsam - es dauert ungefähr dreieinhalb Minuten, bis n = 12 bei Höchstgeschwindigkeit gedruckt wird - daher möchten Sie ihn möglicherweise so ändern, dass 10 Würfelpaare statt 100 gewürfelt werden, indem Sie aa*in der 5. Zeile auf ändern a  (das heißt, agefolgt von zwei Leerzeichen).

Die zufälligen Würfelwürfe werden mit diesem Bit ausgeführt:

1\v/4
2xxx5
3/^\6

Das x s ändern die Richtung des Fisches nach dem Zufallsprinzip. Unter der Annahme, dass dies mit gleichen Wahrscheinlichkeiten implementiert wird, ist es klar, dass das Ergebnis des Würfels eine gleichmäßige Verteilung durch Symmetrie ist.

Sobald der Fisch 100 Würfelpaare gewürfelt hat, zählt er, wie oft die Summe n war mit diesem Bit war (aus Gründen der Übersichtlichkeit und beginnend oben links):

v       /&1+&\
>:@@:@=?/ :?!\}
^   +1oa&0n&}<

Wir behalten n ganz vorne im Stapel und verwenden das Register, um zu zählen, wie oft n angezeigt wird.

Javascript 85 75 Zeichen

Vielen Dank Shaggy!

a=[]
for(i=100;i--;)a[o=(f=_=>Math.random()*6|0)()+f()]=(a[o‌​]|0)+1
alert(a)

Geschichte

85

a={}
f=_=>Math.random()*6
for(i=0;i++<100;)a[o=-~f()-~f()]=(a[o]||0)+1
console.log(a)

Perl 5 , 64 Bytes

map$s{2+int(rand 6)+int rand 6}++,1..100;say"$_ $s{$_}"for 2..12

Probieren Sie es online!

Ausgabeformat:

<sum> <# rolls>

Bei Beträgen ohne Rollen ist die Rollenspalte leer.

PHP, 65 Bytes

while($i++<100)${rand(1,6)+rand(1,6)}++;for(;++$k<13;)echo+$$k,_;

druckt ein Anführungszeichen 0_und dann die Vorkommen von 2 bis 12, gefolgt von einem Unterstrich.
Lauf mit -nroder versuche es online .

K (oK) , 24 22 Bytes

Lösung:

+/(!11)=/:+/(2#100)?'6

Probieren Sie es online!

Erläuterung:

k"Port" meiner qLösung. Die Auswertung erfolgt von rechts nach links, daher Klammern um das til ( !)

+/(!11)=/:+/(2#100)?'6 / the solution
            (2#100)    / the list (100;100)
                   ?'6 / take 6 from each left/each right (roll the dice twice)
           +/          / sum rolls together
  (!11)                / til, performs range of 0..n-1, thus 0..10
       =/:             / equals each right (bucket the sum of the rolls)
+/                     / sum up to get counts per result

Bearbeitungen:

• -2 Bytes, die das jeweils linke für ein jeweils beides und das jeweils linke + Flip für jedes rechte vertauschen

Pyth, 21 Bytes

V100aY,O6O6)VTlfqsTNY

Gibt jeden Schritt bei der Erstellung der Rollen aus und gibt dann die Häufigkeit jeder Summe von 0 bis 10 in einer separaten Zeile aus.

V100aY,O6O6)VTlfqsTNY Full program, no input, outputs to stdout
V100                  For N from 0 to 100
    a ,O6O6           Append a pair of random ints below 6
     Y                To a list Y, initialized to the empty list
           )          Then
            VT        For N from 0 to 10
              f     Y Print Y filtered to only include pairs
                q  N  For which N is equal to
                 sT   The sum of the pair

Java (OpenJDK 8) , 95 Byte

a->{int r[]=new int[11],i=0,d=0;for(;i++<200;)r[d+=Math.random()*6]+=i%2<1?1-(d=0):0;return r;}

Probieren Sie es online!

Erklärungen

a->{
  int r[] = new int[11],     // Rolls or result
      i   = 0,               // Iteration
      d   = 0;               // Dice accumulator
  for (;i++<200;)
    r[d+=Math.random()*6] += // Accumulate a new die and start an addition
     i % 2 < 1               // Accumulate up to two dice
       ? 1 - (d = 0)         // If we're at 2 dice, reset the accumulator and add 1
       : 0;                  // If we only have one die, add 0
  return r;
}