क्या ये पासे नॉनट्रांसिटिव हैं?

Question

Nontransitive पासा अच्छे छोटे खिलौने हैं जो संभाव्यता सिद्धांत में हमारे अंतर्ज्ञान को परिभाषित करते हैं। इस चुनौती के लिए हमें कुछ परिभाषाओं की आवश्यकता होगी:

एक ही समय में फेंके गए दो पासा ए और बी पर विचार करें । हम कहते हैं कि एक धड़कता बी अगर की संभावना एक से एक बड़ी संख्या दिखा बी की संभावना से सख्ती से अधिक है बी की तुलना में एक बड़ी संख्या दिखा एक ।

अब ए , बी , सी लेबल के साथ तीन पासा का एक सेट पर विचार करें । पासों का इस तरह के एक सेट कहा जाता है nontransitive अगर

• या तो A धड़कता है B , B धड़कता है C और C धड़कता है A
• या सी धड़कता बी , बी धड़कता है एक और एक धड़कता सी ।

मेरे पसंदीदा उदाहरणों में से एक के रूप में, ग्रिम पासा पर विचार करें , जिसके निम्नलिखित पक्ष हैं:

A: 3 3 3 3 3 6
B: 2 2 2 5 5 5
C: 1 4 4 4 4 4

^{दिलचस्प बात यह है कि, प्रत्येक मरने का मतलब नियमित मरना की तरह 3.5 है।}

एक यह दिखा सकता है कि:

• एक बी 7 बी की संभावना के साथ धड़कता है ।
• बी धड़कता सी 7/12 की एक संभावना के साथ।
• सी 25/36 की संभावना के साथ ए धड़कता है ।

अब ये विशेष पासे भी अजीब हैं। यदि हम प्रत्येक को दो बार मरते हैं और परिणाम जोड़ते हैं, तो जो धड़कता है उसका क्रम उलट जाता है:

• बी 85/144 की संभावना के साथ ए धड़कता है ।
• सी धड़कता बी 85/144 के एक संभावना के साथ।
• एक धड़कता सी 671/1296 की एक संभावना के साथ।

चलो इस संपत्ति के साथ पासा का एक सेट कहते हैं ग्राईम-नॉनट्रांसिटिव ।

दूसरी ओर, यदि दो फेंकता का उपयोग करते समय पासा उनके मूल चक्र को बनाए रखता है, तो हम उन्हें दृढ़ता से अनाकर्षक कहते हैं । (यदि दो थ्रो के लिए कोई चक्र नहीं है, तो हम बस उन्हें अनैच्छिक कहते हैं ।)

चुनौती

तीन छह पक्षीय पासा, ऊपर गुण इस सेट है की जो निर्धारित करते हैं, और निम्नलिखित तार के उत्पादन में एक को देखते हुए: none, nontransitive, Grime-nontransitive, strongly nontransitive।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं, STDIN, कमांड-लाइन तर्क, प्रॉम्प्ट या फ़ंक्शन तर्क के माध्यम से इनपुट ले सकते हैं, और परिणाम को STDOUT में लिख सकते हैं या इसे एक स्ट्रिंग के रूप में वापस कर सकते हैं।

आप मान सकते हैं कि सभी पक्ष गैर-नकारात्मक पूर्णांक हैं। आप यह नहीं मान सकते कि पक्ष या पासा किसी विशेष क्रम में हैं। आप किसी भी सुविधाजनक सूची या स्ट्रिंग प्रारूप में इनपुट ले सकते हैं।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

परीक्षण के मामलों

none
1 2 3 4 5 6, 6 5 4 3 2 1, 1 3 5 2 4 6
1 1 1 6 6 6, 4 4 4 5 5 5, 5 5 5 5 5 5
1 1 2 5 6 6, 2 2 3 4 4 6, 2 3 3 4 4 5
0 1 2 3 4 5, 1 1 2 3 3 5, 1 2 2 2 3 5
3 13 5 7 13 7, 5 7 11 5 7 13, 5 9 13 5 7 9

nontransitive
1 2 2 4 6 6, 1 2 3 5 5 5, 2 3 4 4 4 4
1 4 4 4 4 4, 2 2 2 4 5 6, 2 3 3 3 5 5
1 2 1 6 5 6, 3 1 3 6 2 6, 2 4 2 4 4 5
3 4 6 6 7 7, 4 4 4 7 7 7, 5 5 5 5 6 7
2 5 11 11 14 14, 5 5 5 14 14 14, 8 8 8 8 8 17

Grime-nontransitive
3 3 3 3 3 6, 2 2 2 5 5 5, 1 4 4 4 4 4
1 1 4 5 5 5, 2 2 2 3 6 6, 3 3 3 4 4 4
2 1 4 6 4 4, 2 4 5 2 3 5, 3 3 6 3 3 3
11 11 13 15 15 16, 12 12 12 13 16 16, 13 13 13 14 14 14
4 4 7 16 19 19, 4 7 13 13 13 19, 4 10 10 10 16 19

strongly nontransitive
2 2 2 5 5 5, 2 3 3 3 5 5, 1 1 4 5 5 5
2 2 2 3 6 6, 2 2 2 5 5 5, 2 2 4 4 4 5
1 5 1 3 6 5, 6 6 4 2 2 1, 5 3 4 3 4 2
0 0 2 4 4 5, 0 1 1 3 5 5, 1 1 2 3 4 4
1 1 9 17 17 21, 1 5 5 13 21 21, 5 5 13 13 13 17

यदि आप अपने कोड को और भी अच्छी तरह से परखना चाहते हैं, तो पीटर टेलर एक संदर्भ कार्यान्वयन लिखने के लिए पर्याप्त थे, जिन्होंने 1 से 6 के पक्षों के साथ पासा के सभी ~ 5000 सेटों को वर्गीकृत किया और 3.5 का मतलब था। पास्टबिन लिंक

Comments

मैं पूरी तरह से गैर-संक्रामक पासा के बारे में भूल गया था। धन्यवाद :)

— npst

क्या पहला निरर्थक उदाहरण सही है? 1 2 2 4 6 6, 1 2 3 5 5 5, 2 3 4 4 4 4मुझे A <B 17/36, B> C 19/36, C <A 16/36 मिल रहा है।

— टोबिया

@ टोबिया आप भूल रहे हैं कि ड्रॉ संभव है। आपको यह भी पता लगाने की आवश्यकता है कि प्रत्येक पासा दूसरों के खिलाफ कितनी बार हारता है, और जांचें कि क्या यह जीतने की संभावना से कम है: हां ए बी के खिलाफ 17/36 के साथ जीतता है, लेकिन ए केवल 16/36 के साथ बी के खिलाफ हारता है, इसलिए ए बी को हरा देता है। इसी तरह, सी ने ए के खिलाफ 16/36 के साथ जीत हासिल की, जैसा कि आपने कहा, लेकिन सी ए के खिलाफ केवल 14/36 के साथ हारता है, इसलिए सी बी को हरा देता है

— मार्टिन एंडर

Answer 1

डायलॉग एपीएल, 107 100 बाइट्स

{({+/×+/¨,¨×⍵∘.-¨1⌽⍵}{3≠|a←⍺⍺⍵:1⋄a=b←⍺⍺∘.+⍨¨⍵:2⋄3+a=-b}⍵)⊃(⊂'none'),'strongly '⍬'Grime-',¨⊂'nontransitive'}

{T←{+/×+/¨∊¨×⍵∘.-¨1⌽⍵}⋄3≠|S←T⍵:'none'⋄N←'nontransitive'⋄S=D←T∘.+⍨¨⍵:'strongly ',N⋄S=-D:'Grime-',N⋄N}

(साभार @Tobia इस सरल, छोटे, बेहतर समाधान के लिए)

मूल बातें:

• ← असाइनमेंट

• ⋄ बयान विभाजक

• {} लंबोदर रूप

• ⍺⍵ बाएँ और दाएँ तर्क

• A:Bगार्ड ("यदि Aफिर वापसी B")

Tएक ऐसा फ़ंक्शन है जो A को बी, बी, सी और बी को ए से बीट करता है तो 3 लौटता है; -3 यदि सटीक विपरीत मामला है; और कुछ इनबेटीन अन्यथा। विस्तार से:

• 1⌽⍵के एक रोटेशन है ⍵। यदि ⍵एबीसी है, तो रोटेशन बीसीए है।

• ∘.-दो वैक्टर के बीच एक घटाव तालिका की गणना करता है ( 1 2...10 ∘.× 1 2...10वह गुणन तालिका होगी जिसे हम स्कूल से जानते हैं)। हम इसे प्रत्येक ( ¨) मद ⍵और इसके संबंधित मद के बीच में लागू करते हैं 1⌽⍵।

• × घटाव तालिकाओं में सभी संख्याओं के हस्ताक्षर

• ∊¨ प्रत्येक तालिका को समतल करें

• +/¨और इसे राशि दें। अब हमारे पास तीन संख्याएँ हैं जो संतुलन का प्रतिनिधित्व करती हैं: ए बनाम बी, बी बनाम सी, सी बनाम ए में से प्रत्येक के लिए जीतने वाले माइनस हारने की संख्या।

• × उन के हस्ताक्षर

• +/ योग

फिर मामलों को बदले में संभालें:

• 3≠|S←T⍵:'none'यदि T⍵पूर्ण मान 3 नहीं है, तो 'कोई नहीं' लौटाएं

• N←'nontransitive' हमें इस शब्द की बहुत आवश्यकता होगी

• S=D←T∘.+⍨¨⍵:'strongly ',NTपासा ( ) ∘.+⍨¨⍵→ ⍵((∘.+)¨)⍵) के जोड़े के लिए गणना करें और "दृढ़ता से ..." वापस करें अगर एबीसी के बीच एक ही रिश्ते अभी भी पकड़ हैं

• S=-D:'Grime-',N ⍝ "ग्रिम" अगर रिश्ते विपरीत दिशाओं में हैं

• N अगर बाकी सब विफल हो जाता है, तो बस "निरंकुश"

Comments

आपने मुझे इसमें हरा दिया! मैं 3 दिन पहले इस समस्या पर काम कर रहा था, लेकिन तब मैंने अपना उत्तर लिखने से कुछ ही समय के लिए रोक दिया। यह आपके लिए वैसे भी समान है, इसलिए मैं इसे यहाँ पोस्ट करूँगा। यह 100 वर्णों में थोड़ा छोटा है:{T←{+/×+/¨∊¨×⍵∘.-¨1⌽⍵}⋄3≠|S←T⍵:'none'⋄N←'nontransitive'⋄S=D←T∘.+⍨¨⍵:'strongly ',N⋄S=-D:'Grime-',N⋄N}

— टोबिया

@ मार्टिनबटनर: शीर्षक में सही शब्द "वर्ण" है, क्योंकि एपीएल प्रतीकों को एनकोड करने के लिए उपयोग किए जाने वाले चारसेट के आधार पर बाइट की मात्रा अलग-अलग होगी। परंपरागत रूप से वे ASCII के बाद केवल 8-बिट बाइट्स के ऊपरी आधे हिस्से में एन्कोडेड थे। आजकल हम यूटीएफ -8 का उपयोग करते हैं, लेकिन पुराने चार्ट अभी भी उपयोगी हैं ... मुख्य रूप से गोल्फ के लिए चरित्र की गिनती को बाइट गिनती को कम करने के लिए!

— टोबिया

@Tobia कोड गोल्फ में पहले छोटे ट्रम्प्स थे, इसलिए आप जीत गए! मैं वास्तव में गोल्फिंग शिष्टाचार से परिचित नहीं हूं, लेकिन मुझे लगता है कि आपको इसे एक अलग उत्तर के रूप में पोस्ट करना चाहिए क्योंकि यह काफी हद तक अलग है और आप स्वतंत्र रूप से इस पर पहुंचे।

— ngn

@ टोबिया मैं पात्रों में भी गिनती करना पसंद करता हूं, लेकिन अगर क्लासिक एन्कोडिंग निहित है, तो बाइट्स = वर्ण, इसलिए शायद यह वास्तव में बहुत ज्यादा मायने नहीं रखता कि हम उन्हें क्या कहते हैं ...

— ngn

@ टोबिया ठीक है कि बाइट द्वारा स्कोर को चुनौती में चरित्र गणना की आपूर्ति करना निश्चित रूप से बेकार है। हालाँकि, किसी ने भी यह नहीं कहा कि हम UTF-8 बाइट में स्कोर कर रहे हैं। वास्तव में टैग विकी स्पष्ट रूप से कहता है कि ASCII रेंज के बाहर के वर्णों के लिए एक अलग मौजूदा एन्कोडिंग का उपयोग किया जा सकता है। और एपीएल का अपना कोडपेज है, इसलिए पूरा कैरेक्टर सेट बाइट के अंदर फिट होता है। PPCG पर नीति APL को गिनने के लिए इस कोडपेज का उपयोग करना है - APL को एएससीआईआई से अधिक उम्र के लिए दंडित करना शायद ही उचित है।

— मार्टिन एंडर

Answer 2

अजगर 2, 269

यहां एक अच्छी छोटी अभिव्यक्ति है जो एक फ़ंक्शन का मूल्यांकन करती है। यह पूर्णांकों की तीन सूचियों को स्वीकार करता है। सभी परीक्षण मामलों को पारित करता है।

lambda A,B,C,w=lambda A,B:cmp(sum(cmp(a,b)for a in A for b in B),0),x=lambda A,B:cmp(sum(cmp(a+c,b+d)for a in A for b in B for c in A for d in B),0): (w(A,B)==w(B,C)==w(C,A)!=0)*((x(A,B)==x(B,C)==x(C,A))*["","strongly ","Grime-"][x(A,B)*w(A,B)]+"nontransitive")or"none"

Answer 3

J - 311 257 bytes

Update (13 Jan 2015):

g=:4 :'(+/,x>/y)>+/,y>/x'
h=:4 :'(,+/~x)g,+/~y'
f=: 3 :0
'a b c'=:y
if. (b g a)*(c g b)*a g c do.
a=.2{y
c=.0{y
end.
'none'([`]@.((a g b)*(b g c)*c g a))((''([`]@.((b h a)*(c h b)*a h c))'Grime-')([`]@.((a h b)*(b h c)*c h a))'strongly '),'nontransitive'
)

Explanation: Using Gerunds, simplify the if.s to @.s.

Older version:

First try at both coding in J as well as golfing.

g=:4 :'(+/,x>/y)>+/,y>/x'
h=:4 :'(,+/~x)g,+/~y'
f=: 3 :0
'a b c'=:y
if. (b g a)*(c g b)*a g c do.
a=.2{y
c=.0{y
end.
if. (a g b)*(b g c)*c g a do.
if. (a h b)*(b h c)*c h a do.
'strongly nontransitive'
elseif. (b h a)*(c h b)*a h c do.
'Grime-nontransitive'
elseif. do.
'nontransitive'
end.
else.
'none'
end.
)

Run it using a syntax similar to following (extra spaces for clarity):

f 3 6 $          1 1 9 17 17 21, 1 5 5 13 21 21, 5 5 13 13 13 17

Explanation:

g is defined as a diad taking two arrays that tells if first dice beats second dice
h is defined as a diad taking two arrays that tells if throwing twice and summing, does first dice beat second
f is a monad that takes a table and returns a string with the right answer

Edit: Fix a mistake in Grime-nontransitive condition (replacing , with *)

Comments

I would love any suggestions for improvement. :)

— Jay Bosamiya

@MartinBüttner, I had initially tried that, but didn't know how to concatenate over several lines (or sentences, as it is known in J) without increasing code length much more... learning about "gerunds" led me to make the many sentences into one which ends up shortening the code as well...

— Jay Bosamiya

Answer 4

Pyth 129 133

Lmsd^b2Msmsm>bkGHDPNK-ghNeNgeNhNR?^tZ<KZKZAGHmsdCm,PkP,yhkyekm,@Qb@QhbUQ?"none"|!G%G3s[*!+GH"Grime-"*qGH"strongly ""nontransitive

Try it here, or at least you could, but the online eval doesn't seem to like lists of lists :( If you want to try it there, manually store a list of 3 dice into a variable not used by the program and then replace all instances of Q with that variable. A sample initialization:

J[[3 3 3 3 3 6)[2 2 2 5 5 5)[1 4 4 4 4 4))

यह मार्टिन के सभी परीक्षण मामलों से गुजरता है, मैं पीटर के सभी मामलों से नहीं गुज़रता: पी

स्पष्टीकरण (यह एक काम करने वाला है)

Lmsd^b2

बहुत सरल है, एक फ़ंक्शन बनाता है yजो प्रत्येक कार्टेशियन जोड़ी के मूल्यों को एक पुनरावृत्त में वापस करता है। समतुल्य करने के लिए: def y(b):return map(lambda d:sum(d),product(b,repeats=2))। यह कई-पक्षीय मरने के लिए उपयोग किया जाता है जो नियमित रूप से दो बार फेंकने का अनुकरण करते हैं।

Msmsm>bkGH

g2 तर्कों के एक फ़ंक्शन को परिभाषित करता है जो रिटर्न करता है कि कितनी बार एक मरने वाला दूसरे को मारता है। के बराबर है def g(G,H):return sum(map(lambda k:sum(map(lambda b:b>k,G)),H)।

DPNK-ghNeNgeNhNR?^tZ<KZKZ

एक Pतर्क को परिभाषित करता है जो अपने तर्क के रूप में दो पासा की सूची लेता है। यह -1 रिटर्न करता है अगर पहली डाई 'हार', एक टाई के लिए 0 और 1 अगर पहली डाई 'जीतती है'। के बराबर:

def P(N):
 K=g(N[0],N[-1]) - g(N[-1],N[0])
 return -1**(K<0) if K else 0

AGHप्रदान करती है एक अजगर 2-टपल काम की तरह कार्य करता है। अनिवार्य रूप सेG,H=(result)

msdCm,PkP,yhkyekm,@Qb@QhbUQ

नक्शे के माध्यम से पीछे की ओर समझाने के लिए जा रहे हैं। m,@Qb@QhbUQबी = 0..2 से अधिक पुनरावृत्त करता है और इंडेक्स बी और इंडेक्स बी + 1 के साथ 2-ट्यूप्स पासा उत्पन्न करता है। यह हमें पासा (ए, बी), (बी, सी), (सी, ए) देता है (सूची की लंबाई से pyth स्वचालित रूप से अनुक्रमित mods)।

अगला, m,PkP,yhkyekपिछले नक्शे के परिणाम पर पुनरावृत्त होता है, प्रत्येक पासा जोड़ी को प्रत्येक रन पर के में संग्रहीत किया जाता है। tuple(P(k),P(tuple(y(k[0]),y(k[-1]))))प्रत्येक मान के लिए लौटाता है । वह `((ए बीट बी ?, 2 * ए बीट्स 2 * बी), (बी बीट्स सी ?, 2 * बी बीट्स ..) को उबालता है।

अंत में, msdCपिछले मानचित्र के मानों को ज़िप किए जाने के बाद निकाल देता है। जिप पहले ट्यूपल में सभी एकल पासा 'बीट्स' मूल्यों का कारण बनता है, और दूसरे में डबल पासा मान।

?"none"|!G%G3s[*!+GH"Grime-"*qGH"strongly ""nontransitive

एक सकल चीज जो परिणामों को प्रिंट करती है। यदि G 0 है या 3 से विभाज्य नहीं है, तो यह bot +/- 3, ( |!G%G3) को प्रिंट करता है none, अन्यथा फॉलिंग सूची के योग को प्रिंट करता है [not(G+H)*"Grime",(G==H)*"strongly ","nontransitive"]:। मुझे लगता है कि प्रश्न में परिभाषाओं के संबंध में बूलियन काफी आत्म-व्याख्यात्मक हैं। ध्यान दें कि जी यहां शून्य नहीं हो सकता है, क्योंकि यह पिछले चेक द्वारा पकड़ा गया है।

Answer 5

जे (204)

बहुत लंबा रास्ता, सही स्ट्रिंग चुनने के लिए एक अधिक कुशल प्रणाली होने से शायद बहुत अधिक गोल्फ हो सकता है।

f=:3 :'(<,>)/"1+/"2>"1,"2(<,>)/L:0{(,.(1&|.))y'
n=:'nontransitive'
d=:3 :0
if.+/*/a=.f y do.+/*/b=.f<"1>,"2+/L:0{,.~y if.a-:b do.'strongly ',n elseif.a-:-.b do.'Grime-',n elseif.do.n end.else.'none'end.
)

Answer 6

मतलाब (427)

यह छोटा नहीं है और मुझे यकीन है कि इसे बहुत अधिक गोल्फ किया जा सकता है, मैंने सिर्फ इस चुनौती को हल करने की कोशिश की क्योंकि मुझे लगा कि यह एक बहुत ही मजेदार काम है, इसलिए इस चुनौती को बनाने के लिए धन्यवाद @ मार्टिनबरनर !

a=input();b=input();c=input();
m = 'non';l=@(a)ones(numel(a),1)*a;n=@(a,b)sum(sum(l(a)>l(b)'));g=@(a,b)n(a,b)>n(b,a);s=@(a,b,c)sum([g(a,b),g(b,c),g(c,a)]);
x=s(a,b,c);y=s(a,c,b);if x~=3 && y~=3;m=[m,'e'];else m=[m,'transitive'];o=ones(6,1);a=o*a;a=a+a';a=a(:)';b=o*b;b=b+b';b=b(:)';c=o*c;c=c+c';c=c(:)';u=s(a,b,c);
v=s(a,c,b);if u==3|| v==3;if x==3&&u==3 || y==3&&v==3 m=['strongly ',m];else m=['Grime-',m];end;end;end;disp(m);

यहां कुछ टिप्पणियों के साथ पूर्ण लंबाई कोड यदि आप यह समझने की कोशिश करना चाहते हैं कि क्या हो रहा है। मैंने कुछ परीक्षण मामलों को शामिल किया और इनपुट आदेशों को छोड़ दिया:

%nontransitive
% a = [1 2 2 4 6 6];
% b = [1 2 3 5 5 5];
% c = [2 3 4 4 4 4];

%none
% a = [1 2 3 4 5 6];
% b = [6 5 4 3 2 1];
% c = [1 3 5 2 4 6];

%grime nontransitive
% a = [3 3 3 3 3 6];
% b = [2 2 2 5 5 5];
% c = [1 4 4 4 4 4];

%strongly nontransitive
% a = [2 2 2 5 5 5];
% b = [2 3 3 3 5 5];
% c = [1 1 4 5 5 5];

m = 'non';

l=@(a)ones(numel(a),1)*a;
n=@(a,b)sum(sum(l(a)>l(b)'));
%input as row vector, tests whether the left one beats the right one:
g=@(a,b)n(a,b)>n(b,a);
s=@(a,b,c)sum([g(a,b),g(b,c),g(c,a)]);
%if one of those x,y has the value 3, we'll have intransitivity
x=s(a,b,c); 
y=s(a,c,b);
if x~=3 && y~=3 %nontransitive
    m=[m,'e'];
else %transitive
    m=[m,'transitive'];
    o=ones(6,1);
    a=o*a;a=a+a';a=a(:)'; %all possible sums of two elements of a
    b=o*b;b=b+b';b=b(:)';
    c=o*c;c=c+c';c=c(:)';
    u=s(a,b,c);
    v=s(a,c,b);

    %again: is u or v equal to 3 then we have transitivity
    if u==3 || v==3 %grime OR strongly
        % if e.g. x==3 and u==3 then the 'intransitivity' is in the same
        % 'order', that means stronlgy transitive
        if x==3 && u==3 || y==3 && v==3%strongly
            m=['strongly ',m];
        else %grime
            m=['Grime-',m];
        end   
    end
end

disp(m);

Comments

क्या यह छोटा नहीं है यदि आप एक सरणी पढ़ते हैं input()और फिर तीन तत्वों को असाइन करते हैं a,b,c? इसके अलावा, कल्पना (में सही तार का उपयोग करें none, nontransitiveऔर पूंजीकृत Grime) ... शायद भी चाहिए बचाने आप बाइट्स।

— मार्टिन एंडर

हाँ, यह शायद कम होगा, मैं उस पर एक नज़र डालूँगा। तार ठीक वैसे ही होंगे जैसे मैंने अभी dispलंबे संस्करण में कमांड हटाए थे, वे सिर्फ प्रोग्राम के परीक्षण के लिए थे, लेकिन अंतिम संदेश में संग्रहीत है m। और मैंने सही किया G।

— दोष

Answer 7

जावास्क्रिप्ट - 276 बाइट्स

function(l){r=function(i){return l[i][Math.random()*6|0]};p=q=0;for(i=0;j=(i+1)%3,i<3;++i)for(k=0;k<1e5;++k){p+=(r(i)>r(j))-(r(i)<r(j));q+=(r(i)+r(i)>r(j)+r(j))-(r(i)+r(i)<r(j)+r(j))}alert((a=Math.abs)(p)>5e3?((a(q)>5e3?p*q>0?'strongly ':'Grime-':'')+'nontransitive'):'none')}

मैं वास्तव में संभावना में अच्छा नहीं हूं, इसलिए अपने परिणामों के बारे में सुनिश्चित होने के लिए, मैं सिर्फ हजारों बार पासा फेंकना पसंद करता हूं।

अभिव्यक्ति एक फ़ंक्शन का मूल्यांकन करती है, जिसे केवल एक तर्क के साथ बुलाया जाना चाहिए: पूर्णांक के तीन सरणियों की एक सरणी। अपने आप से कोड को चलाने में सक्षम होने के लिए फिडल की जांच करें।

यहाँ ungolfed संस्करण है:

function (diceList) {
    var getRandomValue = function (idDie) {
        return diceList[idDie][Math.floor(Math.random() * 6)];
    };

    var probabilitySimpleThrow = 0;
    var probabilityDoubleThrow = 0;

    for (var idDieA = 0; idDieA < 3; ++idDieA)
    {
        var idDieB = (idDieA + 1) % 3;
        for (var idThrow = 0; idThrow < 1e5; ++idThrow)
        {
            probabilitySimpleThrow += getRandomValue(idDieA) > getRandomValue(idDieB);
            probabilitySimpleThrow -= getRandomValue(idDieA) < getRandomValue(idDieB);

            probabilityDoubleThrow += getRandomValue(idDieA) + getRandomValue(idDieA) > getRandomValue(idDieB) + getRandomValue(idDieB);
            probabilityDoubleThrow -= getRandomValue(idDieA) + getRandomValue(idDieA) < getRandomValue(idDieB) + getRandomValue(idDieB);
        }
    }

    if (Math.abs(probabilitySimpleThrow) > 5e3) {
        if (Math.abs(probabilityDoubleThrow) > 5e3) {
            if (probabilitySimpleThrow * probabilityDoubleThrow > 0) {
                var result = 'strongly ';
            }
            else {
                var result = 'Grime-';
            }
        }
        else {
            var result = '';
        }

        result += 'nontransitive';
    }
    else {
        var result = 'none';
    }

    alert(result);
}

Comments

हम्म, मुझे नहीं लगता कि यह वास्तव में चुनौती की भावना में है। आपने मूल रूप से इसे एक संभाव्यता सिद्धांत चुनौती से एक सांख्यिकी चुनौती में बदल दिया। ;) ... यादृच्छिक फेंकता के बजाय, आप बस एक बार बिल्कुल संभव फेंकता फेंक सकते हैं। यह आपको सटीक परिणाम देगा (और बहुत तेज़ी से चलेगा)।

— मार्टिन एंडर

अगर यह एक अधिक संक्षिप्त स्क्रिप्ट की ओर जाता है मैं जाँच करूँगा। आपके सुझाव के लिए धन्यवाद :)।

— ब्लैकहोल