दो छह पक्षीय पासा के 100 रोल की रकम

Question

मान लीजिए कि आपके पास दो छह-पक्षीय पासे हैं। प्रत्येक जोड़ी के योग की गणना करते हुए, जोड़ी को 100 बार रोल करें। प्रत्येक बार होने वाली संख्या का प्रिंट आउट लें। यदि कोई राशि कभी लुढ़की नहीं गई थी, तो आपको यह पहचानने के लिए एक शून्य या कुछ तरीका शामिल करना चाहिए कि वह विशेष राशि कभी लुढ़की नहीं थी।

उदाहरण आउटपुट: [3, 3, 9, 11, 15, 15, 11, 15, 7, 8, 3]

राशि के लुढ़कने की संख्या को सम्स इंडेक्स - 2 में दर्शाया गया है

इस उदाहरण में, दो का योग 3 बार ([2-2]), तीन 3 बार ([3-2]), चार 9 बार ([4-2]) का योग, और ऐसा ही था। पर। यह एक बिंदु पर आने के लिए व्यक्तिगत पासा रोल से कोई फर्क नहीं पड़ता (5 और 2 को 6 और 1 के समान योग में गिना जाएगा)

"अग्ली" आउटपुट ठीक हैं (जब तक कि डेटा को कैसे पढ़ा जाना चाहिए, यह समझाते हुए लोडिंग शून्य, अतिरिक्त आउटपुट, डेटा का प्रतिनिधित्व करने के अजीब तरीके आदि)।

Comments

क्या आपका मतलब है "कई बार प्रत्येक जोड़ी की आवृत्ति दर्शाता प्रिंट आउट" या "बार प्रत्येक की संख्या प्रिंट आउट योग हुई"?

— फल तोड़ना

यदि कोई विशेष राशि कभी नहीं आती है, तो क्या 0सूची में होने की आवश्यकता है , या क्या इसे छोड़ा जा सकता है?

— ग्रेग मार्टिन

क्या अलग-अलग मूल्यों को लगातार पहचानने की आवश्यकता है या क्या अकेले गिनती पर्याप्त है?

— जोनाथन एलन

यदि आउटपुट प्रत्येक जोड़े के संयोजन की संख्या का सिर्फ एक बार होता है, तो हमें प्रत्येक रोल के मूल्य को योग करने की आवश्यकता क्यों है? हम उस कुल के साथ क्या करने वाले हैं? "बदसूरत" से आपका क्या मतलब है?

— झबरा

extra outputलेकिन हम अभी भी यादृच्छिक संख्याओं की एक अनंत सूची का उत्पादन नहीं कर सकते हैं और कहते हैं कि यह यादृच्छिक रूप से वहां कहीं दिखाई देता है, है ना? यह एक मानक खामियों को दूर करने वाला है।

— स्टीफन

Answer 1

जेली , 13 12 बाइट्स

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

एक निलादिक कड़ी। आउटपुट प्रारूप की सूचियों की एक सूची है [value, count]।

(शून्य रोल का मतलब है कि ऐसी कोई प्रविष्टि आउटपुट में मौजूद नहीं है - उदाहरण के लिए एक आउटपुट [[6, 12], [7, 74], [8, 14]]यह पहचानता है कि केवल छह, सात और आठ के योगों को रोल किया गया था।)

इसे ऑनलाइन आज़माएं!

कैसे?

³Ḥ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)

Answer 2

पायथन 2 , 84 77 76 बाइट्स

-7 बाइट्स @JonathanAllan
-1 बाइट की बदौलत @FelipeNardiBatista को धन्यवाद

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

इसे ऑनलाइन आज़माएं!

आउटपुट में दो प्रमुख शून्य हैं

Comments

76 बाइट्स TIO के

— फेलिप

Answer 3

05AB1E , 21 19 बाइट्स

-2 बाइट्स @Emigna की बदौलत

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

इसे ऑनलाइन आज़माएं!

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

Comments

TÝÌтF6Lã.RO¸ì}{γ€g<2 बाइट्स बचाता है।

— एमिग्ना

@Eigna, कम होने की उम्मीद नहीं की, धन्यवाद!

— कलसवरस

Answer 4

गणितज्ञ, 50 बाइट्स

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

सीधा कार्यान्वयन। यदि कोई राशि कभी प्राप्त नहीं होती है, 0तो सूची से छोड़ दिया जाता है।

Answer 5

MATL , 17 बाइट्स

6H100I$Yrs!11:Q=s

आउटपुट 11 नंबरों की सूची है (उनमें से कुछ संभवतः 0) रिक्त स्थान द्वारा अलग किए गए हैं, जो प्रत्येक जोड़ी के लिए 2 से 12 तक की संख्या को दर्शाता है।

इसे ऑनलाइन आज़माएं!

तुलना के लिए, प्रत्येक जोड़ी में औसतन दिखाई देने वाली सैद्धांतिक औसत संख्या की गणना की जा सकती है 6:gtY+36/100*।

यदि रोल की संख्या में वृद्धि हुई है, तो प्राप्त होने वाले मानों को दृष्टिकोण मिलता है। उदाहरण के लिए देखें 10000 रोल के साथ प्राप्त और सैद्धांतिक मान।

Answer 6

सीजाम, 18 20 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

यह एक बदसूरत प्रारूप में आउटपुट करता है - प्रत्येक रोल की संख्या को निरंतर खंडों की लंबाई के रूप में दर्शाया जाता है।

— फल तोड़ना

@JonathanAllan सब ठीक है, ठीक है। e` केवल दो बाइट्स लेता है।

— फल तोड़ना

Answer 7

पर्ल 6 , 30 बाइट्स

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

(^6).pickपांच में से शून्य से एक यादृच्छिक संख्या है। xx 100ऐसे नंबरों की सौ-तत्व सूची बनाता है। xx 2ऐसी दो सूचियों का निर्माण करता है। [Z+]उन दो सूचियों को जोड़ देता है, दो-मरने वाले रोल की सौ-तत्व सूची का निर्माण करता है। अंत में, bagउस सूची को एक बैग में रखता है, जो कि बहुलता के साथ एक संग्रह है। उदाहरण REPL आउटपुट:

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

इसका मतलब है कि 1, 9, और 0 प्रत्येक चार बार हुए, चार चौदह बार हुए, आदि। चूंकि इस कोड में "पासा" 0-5 से एक संख्या का उत्पादन करता है, रोल को पाने के लिए इनमें से प्रत्येक संख्या में दो जोड़ दें। मानक 1-6 पासा का उत्पादन होगा।

Comments

वाह। पर्ल 6 एक ऐसी ताकत है जिसके साथ प्रतिध्वनित होना है।

— जैकब

हालांकि, "यदि कोई राशि कभी भी लुढ़की नहीं थी, तो आपको एक शून्य या किसी तरह से यह पहचानने के लिए शामिल करना चाहिए कि उस विशेष राशि को कभी भी लुढ़काया नहीं गया था।" ऐसा नहीं लगता कि बैग समाधान संतुष्ट करता है।

— जकॉब

यदि किसी विशेष नंबर को रोल नहीं किया गया था, तो बैग में नंबर की अनुपस्थिति से उस स्थिति की पहचान की जा सकती है।

— शॉन

Answer 8

आर , 45 37 बाइट्स

-7 बाइट्स जर्को डबल्डम के लिए धन्यवाद

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

प्रत्येक के तत्वों और गणनाओं की एक तालिका ऑब्जेक्ट लौटाता है। किसी भी ऐसे मान को छोड़ दें जो नहीं हुआ।

इसे ऑनलाइन आज़माएं!

पुराना संस्करण:

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

sample(6,200,T)1:6प्रतिस्थापन के साथ समान रूप से 200 बार के नमूने , फिर यह 2 पंक्तियों के साथ एक मैट्रिक्स बनाता है, कॉलम को सॉम्प करता है, फिर उन्हें आरोही क्रम में सॉर्ट करता है और रनों की लंबाई की गणना करता है। किसी भी पासा रकम का लाभ उठाता है।

एक rleवस्तु लौटाता है , जो निम्नलिखित प्रारूप में डिफ़ॉल्ट रूप से प्रिंट होता है:

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

जहां lengthsगिना जाता है और valuesपासा रकम है।

TIO लिंक

Answer 9

PHP, 53 बाइट्स

एक साहचर्य सरणी प्रिंट करता है। कुंजी दो चरणों का परिणाम है और मूल्य इन परिणामों की गिनती है

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

इसे ऑनलाइन आज़माएं!

Comments

If a sum was never rolled, you must include a zero or some way to identify that that particular sum was never rolled.

— टाइटस

Answer 10

जावास्क्रिप्ट (ईएस 6), 72 बाइट्स

"बदसूरत" आउटपुट के रूप में देखने की अनुमति दी जाती है, निम्नलिखित एक सरणी का उत्पादन करेगा जिसमें 2-12 से प्रत्येक अंक को रोल किया गया था, जिसमें 0 से सेट किए गए अतिरिक्त 89 तत्व थे।

_=>(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>

Comments

क्या आप इसे 99 या 20 या सिर्फ 12 के बजाय 100 तत्व बनाने के लिए एक बाइट बर्बाद नहीं कर रहे हैं?

— रोहन झुनझुनवाला

@ रोहन झुनझुनवाला, चुनौती दो पासा के 100 रोल के लिए कहता है।

— झबरा

ओह, मुझे लगा कि रोल को स्टोर करने के लिए सिर्फ 100 एलिमेंट ऐरे को इनिशियलाइज़ कर रहे हैं।

— रोहन झुनझुनवाला

Answer 11

एसआईओएस , 99 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पासा को रोल करता है, और उन्हें ढेर के पहले 11 स्थानों में संग्रहीत करता है, फिर बस प्रत्येक काउंटर को मुद्रित करने वाले ढेर के माध्यम से पुनरावृत्ति करता है। यह असाइनमेंट ऑपरेटर के साथ संयुक्त रैंड कीवर्ड के पहले रिकॉर्ड किए गए उपयोगों में से एक है।

यह ध्यान देने योग्य है, कि रोल के हिस्टोग्राम को आउटपुट करने के लिए कुछ संशोधन किए जा सकते हैं।

दुर्भाग्य से यह ऑफ़लाइन दुभाषिया से चलाया जाना चाहिए ।

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

Answer 12

अमृत, 157 118 बाइट्स

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

जेली की तुलना में कुछ कठिन कोशिश की।

स्पष्टीकरण:

1. फ़ंक्शन को परिभाषित करें जो 1 और 6 समावेशी के बीच एक यादृच्छिक संख्या देता है।
2. फ़ंक्शन को गुमनाम रूप से परिभाषित करें और yरोल योग के साथ चर होने दें ।
3. 1 जोड़कर सूची में उपयुक्त स्थान अपडेट करें।
4. अगर हम 100 रोल में हैं, तो छोड़ दें। Else अपने आप को फिर से अपने आप में और अद्यतन सूची से गुजर रहा है।
5. अपडेट की गई सरणी लौटाएं।

की तरह बुलाया जाना चाहिए p.(p,[0,0,0,0,0,0,0,0,0,0,0,0,0])। यह एक चेतावनी बढ़ाएगा, लेकिन यह 13 तत्वों के साथ वांछित सरणी लौटाएगा, पहले 2 को अनदेखा किया जाना चाहिए।

Answer 13

जावा 8, 104 बाइट्स

एक लंबोदर int[]आवृत्तियों की वापसी । को सौंपा Supplier<int[]>।

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

यह ऑनलाइन की कोशिश करो

अघोषित लंबोदर

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

Answer 14

क्यू / केडीबी +, ३१ २ by २५ बाइट्स

समाधान:

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

उदाहरण:

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

स्पष्टीकरण:

एक पासा 100?6रोल करें, एक पासा फिर से रोल करें और एक साथ वैक्टर जोड़ें। फिर देखें कि प्रत्येक परिणाम 0..10 की सीमा से मेल खाता है, फिर प्रत्येक सूची में सभी trues का योग करें:

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

टिप्पणियाँ:

'गोल्फिंग' अधिकतर समकक्षों, अर्थात् और के qलिए कीवर्ड स्वैप कर रहा है ।keachtil

Answer 15

QBIC , 45 बाइट्स

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

स्पष्टीकरण:

[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

Answer 16

एपीएल, 14 बाइट्स

,∘≢⌸+/?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

---

पिछला पद:

एपीएल, 36 31 बाइट्स

5 बाइट्स @ Adám की बदौलत बच गए

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

व्याख्या

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

कैसे काम 11⍴⍉⌽fकरता है?

⍝ ⌽ - 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

Comments

बयानों को जोड़कर और ऑपरेंड (11⍴⍉⌽f)[⍋11⍴⍉f←,∘⍴⌸+/?100 2⍴6]

— टैसीट

क्षमा करें, आपने इसे शामिल करते हुए मैंने अपना सुझाव संपादित किया। टैसीट ऑपरेंड पर ध्यान दें।

— Adám

हालांकि, ओपी किसी भी अस्पष्ट आउटपुट प्रारूप की अनुमति देता है, इसलिए ,∘⍴⌸+/?100 2⍴6यह पर्याप्त होना चाहिए, क्योंकि यह होने वाली रकमों को सूचीबद्ध करता है (इस प्रकार यह दर्शाता है कि कौन से लोग नहीं हैं) और उनकी आवृत्तियों (इसलिए कोई छंटाई की आवश्यकता नहीं है)।

— एडम

Answer 17

> <> , 93 बाइट्स

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

इसे ऑनलाइन आज़माएं , या इसे मछली के खेल के मैदान में देखें !

बदसूरत आउटपुट स्वरूप newlines द्वारा अलग किए गए संख्याओं का एक क्रम है, जहां n th संख्या कहती है कि योग कितनी बार n था - यह बदसूरत है क्योंकि यह हमेशा के लिए प्रिंट करता है, सभी सकारात्मक पूर्णांक n के लिए , हालांकि अधिकांश लाइनें 0. होगी ( TIO लिंक को 5 बाइट्स की कीमत पर n = 12 के बाद बंद करने के लिए संशोधित किया गया है ।)

मछली का खेल का मैदान काफी धीमा है - शीर्ष गति पर n = 12 तक प्रिंट करने में लगभग साढ़े तीन मिनट लगते हैं - इसलिए आप इसे aa*5 वीं पंक्ति में बदलकर 100 के बजाय 10 जोड़े पासे को रोल करने के लिए संशोधित करना चाह सकते हैं। a  ( aअर्थात् दो स्थानों के बाद)।

यादृच्छिक पासा रोल इस बिट द्वारा किया जाता है:

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

xरों मछली की दिशा बेतरतीब ढंग से बदल जाते हैं। यह मानते हुए कि समान संभावनाओं के साथ लागू किया गया है, यह स्पष्ट है कि डाई रोल परिणाम समरूपता द्वारा एक समान वितरण है।

एक बार मछली ने 100 जोड़ी पासा लुढ़का दिया, तो यह गणना करता है कि इस बिट के साथ कितनी बार n था (स्पष्टता के लिए अपरिवर्तित, और शीर्ष बाएं में शुरू):

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

हम स्टैक के सामने n रखते हैं , और n की संख्या को प्रदर्शित करने के लिए रजिस्टर का उपयोग करते हैं ।

Answer 18

जावास्क्रिप्ट 85 75 अक्षर

धन्यवाद झबरा!

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

इतिहास

85

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

Comments

इसके लिए आपको कुछ बचत देने का अर्थ है; यहाँ आपके समाधान का एक बहुत जल्दी गोल्फ बाइट संस्करण है a=[];for(i=100;i--;)a[o=(f=_=>Math.random()*6|0)()+f()]=(a[o]|0)+1;alert(a):। (नोट: इस उदाहरण में, IIFE न तो किसी भी बाइट की बचत करता है और न ही खर्च करता है, लेकिन कई बार ऐसा होता है जब यह आपको बाइट या 2 बचा सकता है, इसलिए इसे आपके "गोल्फबैग" में रखना आसान है।)

— Shaggy

ओह, बहुत बढ़िया, धन्यवाद। वहाँ उपयोगी ट्रिक्स! इतना दिलचस्प है कि |0"Math.floor ()" और भी "अपरिभाषित 0 में परिवर्तित" करने के लिए गोल्फ समाधान है।

— स्टीव बेनेट

Answer 19

पर्ल 5 , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आउटपुट स्वरूप:

<sum> <# rolls>

शून्य रोल के साथ रकम के लिए, रोल कॉलम रिक्त है।

Answer 20

PHP, 65 बाइट्स

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

एक प्रमुख 0_और फिर 2 से 12 की घटनाओं को प्रिंट करता है , इसके बाद प्रत्येक अंडरस्कोर होता है। इसे ऑनलाइन
चलाएं -nrया इसके लिए प्रयास करें ।

Answer 21

के (ओके) , 24 22 बाइट्स

समाधान:

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

kमेरे qसमाधान का 'पोर्ट' । मूल्यांकन दाएं-बाएं होता है, इसलिए तिल के चारों ओर कोष्ठक ( !)

+/(!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

संपादन:

• -2 बाइट्स प्रत्येक-दोनों के लिए प्रत्येक-बाएं स्विचिंग, और प्रत्येक-दाएं के लिए प्रत्येक-बाएं-फ्लिप

Answer 22

पायथ, 21 बाइट्स

V100aY,O6O6)VTlfqsTNY

रोल के निर्माण में प्रत्येक चरण को आउटपुट करता है, फिर प्रत्येक पंक्ति 0 - 10 की आवृत्ति को एक अलग लाइन पर आउटपुट करता है।

---

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

Answer 23

जावा (ओपनजेडके 8) , 95 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण

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