ब्रह्मांड का अनुकरण करें!

103

ट्यूरिंग-पूर्ण भाषा की एक अच्छी संपत्ति यह है कि इसका उपयोग किसी भी कार्यक्रम को लिखने के लिए किया जा सकता है, पूरे ब्रह्मांड के अनुकरण तक और इसमें शामिल है।

आपका काम ठीक यही करना है: एक प्रोग्राम लिखें जो यूनिवर्स का अनुकरण करता है ।

नोट: हालांकि मुझे संदेह नहीं है कि आप इस कार्य को पूरा करने में सक्षम होंगे, आजकल मेरे पास यह सत्यापित करने के लिए पर्याप्त समय नहीं है कि आपके सिमुलेशन के सभी 10 90 कण क्या वे वास्तव में करना चाहिए। इसलिए, केवल परीक्षण और मूल्यांकन को आसान बनाने के लिए, यह पर्याप्त है यदि आपका ब्रह्मांड सिम्युलेटर केवल एक ही प्रारंभिक कण के साथ काम करता है। चीजों को दिलचस्प रखने के लिए, मान लें कि यह कण हाल ही में खोजा गया हिग्स बोसोन है।

आपका ब्रह्मांड कुछ भी नहीं है, लेकिन इसके बीच में लगभग 120 GeV का एक हिग्स बोसोन है। उत्पादन बहुत लंबा नहीं बनाने के लिए, के केवल 10 पर इस ब्रह्मांड टिक करते हैं -25 5.4 × 10 के अपने "सामान्य घड़ी दर" के बजाय सेकंड -44 सेकंड ..

यह हिग्स बोसोन जल्दी या बाद में क्षय हो जाएगा क्योंकि इसमें 1.6 × 10 at22 सेकंड का आधा जीवन होता है , इसलिए सिमुलेशन के प्रत्येक टिक पर, इसका क्षय होने का 0.0433% मौका होता है। आप यहां देख सकते हैं कि यह क्या क्षय होगा । एक केंद्रीय और सरलीकृत आवश्यकता होने के लिए, मुझे आपके द्वारा उपयोग की जाने वाली शाखाओं की सूची देनी चाहिए:

अनुकरण चल रहा है

सिमुलेशन के प्रत्येक टिक पर, हिग्स बोसोन में क्षय की 0.0433% संभावना है। यदि ऐसा होता है, तो यह सूचीबद्ध कणों के साथ निम्नलिखित कणों में क्षय होगा (आपको आउटपुट में इन नामों का उपयोग करना चाहिए):

  • निचला क्वार्क + निचला एंटिकार्क (64.8%)
  • 2 डब्ल्यू बोसॉन (14.1%)
  • 2 ग्लून्स (8.82%)
  • ताऊ लेप्टान + एंटीटा लेप्टन (7.04%)
  • आकर्षण क्वार्क + आकर्षण एंटिकार्क (3.27%)
  • 2 जेड बोसॉन (1.59%)
  • 2 फोटॉन (0.223%)
  • 1 जेड बोसॉन + 1 फोटॉन (0.111%)
  • म्यूऑन + एंटीमुअन (0.0244%)
  • शीर्ष क्वार्क + शीर्ष एंटीकार्क (0.0216%)

कुल 100% के लिए।

इनमें से कुछ कण आगे क्षय हो जाएंगे।

डब्ल्यू बोसॉन : 10 -25 सेकंड का आधा जीवन , इसका मतलब है कि प्रत्येक टिक में क्षय होने की 50% संभावना निम्न में से एक में समान संभावनाओं के साथ होती है:

  • पॉज़िट्रॉन + न्यूट्रिनो
  • एंटीमुअन + न्यूट्रिनो
  • एंटीटा लेप्टान + न्यूट्रिनो

Z बोसॉन : 10 -25 सेकंड का आधा जीवन , इसका मतलब निम्न में से प्रत्येक में प्रत्येक टिक को क्षय करने का 50% मौका है:

  • न्यूट्रिनो + एंटीन्यूट्रिनो (20.6%)
  • इलेक्ट्रॉन + पॉज़िट्रॉन (3.4%)
  • म्यूऑन + एंटीमुअन (3.4%)
  • ताऊ लेप्टान + एंटीटा लेप्टन (3.4%)
  • डाउन क्वार्क + डाउन एंटीकार्क (15.2%)
  • अजीब क्वार्क + अजीब एंटीकार्क (15.2%)
  • निचला क्वार्क + निचला एंटिकार्क (15.2%)
  • अप क्वार्क + अप एंटीकार्क (11.8%)
  • आकर्षण क्वार्क + आकर्षण एंटिकार्क (11.8%)

शीर्ष क्वार्क : 5 × 10 -25 सेकंड का आधा जीवन , इसका मतलब है कि नीचे दिए गए प्रत्येक टिक पर क्षय होने की संभावना के साथ 12.95% मौका है:

  • डब्ल्यू बोसॉन + डाउन क्वार्क
  • डब्ल्यू बोसोन + अजीब क्वार्क
  • डब्ल्यू बोसोन + निचला क्वार्क

बेशक, डब्ल्यू बोसोन भी जल्द ही क्षय होगा ...

शीर्ष क्वार्क शीर्ष क्वार्क की तरह ही बर्ताव करता है: यह एक डब्ल्यू बोसॉन और विज्ञापन / एस / b क्वार्क में क्षय।

अन्य सभी कण (इसलिए जेड और डब्ल्यू बोसॉन और शीर्ष क्वार्कों को छोड़कर) में आधा जीवन कई बार परिमाण के कई आदेश होते हैं, इसलिए आउटपुट को अव्यवस्थित नहीं करने के लिए, वे सभी हमारे सिमुलेशन के लिए स्थिर माने जाते हैं ।

चूंकि ब्रह्मांड काफी हद तक खाली है, सभी कणों में अपने लिए पर्याप्त जगह होगी और एक दूसरे के साथ बातचीत नहीं करेंगे। इसलिए सभी व्यक्तिगत कण हर संबंध में एक दूसरे से स्वतंत्र होते हैं, जिसमें विभाजन की संभावनाएं भी शामिल हैं।

आउटपुट:

सिमुलेशन के प्रत्येक टिक, आपको सिम्युलेटेड ब्रह्मांड की सामग्री को एक नई पंक्ति में प्रिंट करना होगा। उदाहरण के लिए:

The universe contains 1 Higgs boson.
The universe contains 1 Higgs boson.
The universe contains 1 Higgs boson.
The universe contains 1 Higgs boson.
The universe contains 2 W bosons.
The universe contains 2 W bosons.
The universe contains 1 W boson, 1 positron and 1 neutrino.
The universe contains 1 positron, 1 antitau lepton and 2 neutrinos.
Simulation ended after 0.8 yoctoseconds.

लाइन में कणों का क्रम महत्वपूर्ण नहीं है। स्वरूपण, हालांकि, उपरोक्त उदाहरण में बिल्कुल होना चाहिए , जिसमें विराम चिह्न और बहुवचन शामिल हैं। यदि आप एक संपूर्ण (मिनी) ब्रह्मांड का अनुकरण करते हैं, तो यह अच्छा लगना चाहिए (और मैं पर्याप्त रूप से आवश्यक उत्पादन आवश्यकता के दुरुपयोग को समाप्त नहीं करना चाहता था)

प्रत्येक पंक्ति 0.1 yoctoseconds से मेल खाती है, लेकिन यदि आपके प्रोग्राम को आउटपुट प्रिंट करने में इससे अधिक समय लगता है, तो आपको माफ कर दिया जाएगा।

अनुकरण समाप्त होता है जब केवल "स्थिर" कण रहते हैं।

स्कोरिंग

मानक कोड गोल्फ नियम लागू होते हैं।

यादृच्छिक संख्या जनरेटर छद्म यादृच्छिक हो सकता है, लेकिन यदि भाषा डिफ़ॉल्ट रूप से इसे बीज नहीं देती है, तो आपको इसे बीज देना चाहिए। आपके RNG की संभावना वितरण एक समान होना चाहिए।

  • यदि प्रोग्राम एक इनपुट के रूप में पूर्णांक लेता है, तो आपको कोड आकार में एक बोनस -10% मिलेगा, और यह कई हिग्स बोसॉन के साथ शुरू होता है।

ट्यूरिंग मशीन के प्रति उत्साही के लिए अपवाद।

जो लोग एक वास्तविक ट्यूरिंग मशीन या इसी तरह की भाषा (जैसे ब्रेनफक) के साथ अपनी किस्मत आजमाने की हिम्मत करते हैं , उनके कार्य को निम्नलिखित नियम परिवर्तनों द्वारा आसान बनाया जाता है (केवल तभी लागू होता है जब भाषा ब्रेनफैक-व्युत्पन्न होती है या अन्यथा बहुत सरल ट्यूरिंग- मशीन, असाइन करने में असमर्थ, ALU की कमी, और टेप पर मान केवल एक के द्वारा बढ़ा और घटाया जा सकता है) :

  • कण नामों को डी, एस, बी, टी, यू, सी के लिए क्वार्क, वी के लिए न्युट्रीनो, टी के लिए ताऊ लेप्टान, एम के लिए एम, ग्लोन के लिए जी, फोटॉन के लिए पी, जेड, डब्ल्यू और एच के लिए सरलीकृत किया जाता है। बोसोन, - इलेक्ट्रॉन के लिए और पॉज़िट्रॉन के लिए। प्रत्येक टिक पर, 0 या 1 के मान के साथ एक इनपुट मानक इनपुट से प्रदान किया जाता है, यह इंगित करता है कि सूची में पहला अस्थिर कण तय होता है या नहीं।

इसलिए उदाहरण आउटपुट बन जाएगा

H
H
H
H
W W
W W
W + n
+ !T n n
code-golf  random  simulation  physics 
— vsz
स्रोत
76
क्या गणितज्ञ के पास एक SimulateUniverseअंतर्निहित कार्य है?
— डिजिटल ट्रामा
14
तो ... इस ब्रह्मांड में एक बड़ा धमाका नहीं है ... - बस एक छोटा सा धमाका?
— लेवल रिवर सेंट
3
यदि एक शीर्ष क्वार्क का क्षय होता है, तो क्या एक शीर्ष प्रतिपक्षी क्षय भी नहीं होना चाहिए? मुझे लगता है कि यह कोई फर्क नहीं पड़ता, नियम नियम हैं। लेकिन भौतिक विज्ञान भौतिकी है (और मेरा कण भौतिकी बहुत अच्छा नहीं है, लेकिन यह अजीब लगता है।)
— स्तर नदी सेंट
23
हमारा पूरा ब्रह्मांड एक कोड गोल्फ चुनौती हो सकता है।
— coredump
18
मुझे लगता है कि मैं इस चुनौती पर सर्वश्रेष्ठ रहूंगा ...;)
— बीटा डेके

जवाबों:

1

पायथ , 572 * 0.9 = 514.8 बाइट्स

Jm?tld,hd,-1^.5c1shced\ sm*]<k2s>k2tced\ dcR\,cu:GhHtHc"A76 !B17 !C1 v!D_top !E00 !F bosR!GmuR_!Ineutrino_!Jtau leptR_!KQ_charm !LQ_strange !MQ_down !NQ_up !OQ_bottom !Panti!Qquark!Ron"\!"HiggsF,16Efg3240Ebb705Epp441Eqr352ER16350 cc7950 ss1115 cs555 tu122 de108_WF,CxCuCr1_ZF,Cw103 yxBtuBqrBjkAlmAfgAhi59 R59DQ,5 bj1 bl1 bf1DPOOPNNPMMPLLPKKPQ_gluR_JPJphotR_GPGIPIpositrR_electrR"\_L%"The universe contains %s.":j", "fT.e?bs[b\ h@Jk?tb\s"")0b",(?!.*,)"" and"K+Q*]Z24Ws<K4yK=+Z1Vs.em?>O1.0he@JkY,kOee@Jkb<K4IN XhNK_1 XRK1xLGeN;yK%"Simulation ended after %s yoctoseconds."cZT

-10% बोनस के लिए योग्य। इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर हिग्स बोसोन आधा जीवन घटाकर 1ys करने का प्रयास करें (उत्पादन में कम पुनरावृत्ति के लिए बनाता है, और अधिक रोमांचक ब्रह्मांड!)।

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

कार्यक्रम को तीन भागों में विभाजित किया गया है - शब्दकोश तैयार करना, आउटपुट फ़ंक्शन परिभाषा और सिमुलेशन निष्पादन।

शब्दकोश तैयारी

Jm?tld,hd,-1^.5c1shced\ sm*]<k2s>k2tced\ dcR\,cu:GhHtHc"A76 !B17 !C1 v!D_top !E00 !F bosR!GmuR_!Ineutrino_!Jtau leptR_!KQ_charm !LQ_strange !MQ_down !NQ_up !OQ_bottom !Panti!Qquark!Ron"\!"HiggsF,16Efg3240Ebb705Epp441Eqr352ER16350 cc7950 ss1115 cs555 tu122 de108_WF,CxCuCr1_ZF,Cw103 yxBtuBqrBjkAlmAfgAhi59 R59DQ,5 bj1 bl1 bf1DPOOPNNPMMPLLPKKPQ_gluR_JPJphotR_GPGIPIpositrR_electrR"\_

यह समाप्त कोड का सबसे बड़ा खंड है, जो 381 बाइट्स लेता है। निम्नलिखित स्ट्रिंग का उपयोग करके शब्दकोश बनाया गया है:

Higgs boson,1600 fg324000 bb70500 pp44100 qr35200 on16350 cc7950 ss1115 cs555 tu122 de108_W boson,1 vx1 vu1 vr1_Z boson,1 vw103 yx17 tu17 qr17 jk76 lm76 fg76 hi59 on59_top quark,5 bj1 bl1 bf1_top antiquark_bottom quark_bottom antiquark_up quark_up antiquark_down quark_down antiquark_strange quark_strange antiquark_charm quark_charm antiquark_gluon_tau lepton_antitau lepton_photon_muon_antimuon_neutrino_antineutrino_positron_electron

स्ट्रिंग कणों की एक अंडरस्कोर अलग की गई सूची है और, यदि कण अस्थिर है, तो इसका व्यवहार - एक अंतरिक्ष अलग सूची सिमुलेशन सिमुलेशन में अपने आधे जीवन से मिलकर बनता है और उसके बाद प्रत्येक के अलग-अलग प्रोबाइली के साथ यह क्या होता है। प्रत्येक कण में इससे जुड़ा एक एकल-अक्षर कोड होता है, जो निचले स्थिति वर्णमाला में अनुक्रमित सूची में उनकी स्थिति के अनुसार दिया जाता है - इसलिए हिग्स बोसोन a, डब्ल्यू बोसोन है b, जो इलेक्ट्रॉन के लिए सभी तरह से है y।

क्षय संभावनाओं को संग्रहीत करने के बजाय, आधे जीवन को संग्रहीत किया जाता है और शब्दकोश संसाधित होने पर संभाव्यता की गणना की जाती है। उपयोग किया गया सूत्र वह है P=1-(1/2)^(1/h)जहां Pप्रति टिक को क्षय करने की संभावना है, और टिक hमें मापे गए कण का आधा जीवन है।

अस्थिर कण सूची में पहले चार हैं। जैसा कि इन कणों की संख्या है, जो निर्धारित करता है कि सिमुलेशन कब समाप्त होता है, सूची की शुरुआत में ये होने से उन्हें बाद में जांचना आसान हो जाता है।

समस्या यह है कि यह स्ट्रिंग विशाल है - 436 बाइट्स! - और पाइथ के अंतर्निहित स्ट्रिंग संपीड़न का उपयोग करने से वास्तव में बाइट की गिनती बढ़ जाती है, क्योंकि यह बहुत सारे मल्टी-बाइट पात्रों का उपयोग करता है। मैं अपेक्षाकृत सरल पुनरावृत्ति शब्दकोश संपीड़न योजना पर बस गया हूं। स्निपेट u:GhHtHc"xxx"\!"yyy"इसे निम्न प्रकार से व्याख्या करता है:

u:GhHtHc"xxx"\!"yyy"   xxx -> dictionary, yyy -> encoded string
       c"xxx"\!        Chop the dictionary on !
u              "yyy"   Reduce the above, with initial state as encoded string, using:
 :G                      In the current string, replace...
   hH                    ... the first character of the dictionary entry...
     tH                  ... with the remainder of the dictionary entry

मेरे द्वारा चुनी गई शब्दकोश प्रविष्टियाँ केवल मेरे अंतर्ज्ञान और कुछ परीक्षण और त्रुटि पर आधारित हैं, इसलिए मुझे यकीन है कि सुधार के लिए बहुत जगह है।

डिकम्प्रेस्ड डिक्शनरी स्ट्रिंग की व्याख्या तब की जाती है जब उसे नीचे वर्णित किया जाता है:

Jm?tld,hd,-1^.5c1shced\ sm*]<k2s>k2tced\ dcR\,cxxx\_   xxx -> decompressed dictionary
                                              cxxx\_   Split the string on underscores
                                          cR\,         Split each part on commas
 m                                                     Map each element (particle), d, using:
  ?tld                                   d               Is the element length >1? If not, no change, otherwise...
      ,hd                                                  Create a pair consisting of the particle's name and...
                   ced\                                      Split the decay data on spaces
                 sh                                          Parse 1st element (half life) as int
          -1^.5c1                                            Calculate per-tick decay probability
         ,                                                   Pair the above with...
                         m         tced\                       Map the rest of the decay data, k, using:
                           ]<k2                                  Take the 1st two characters
                               s>k2                              Parse the rest of the characters as a string
                          *                                      Repeat the characters that many times
                        s                                      Flatten the list
J                                                      Store the processed dictionary in J

परिणाम यह है कि Jकण नामों की एक आदेशित सूची शामिल है। यदि वे क्षय करते हैं, तो नाम को उनके क्षय की संभावना और कणों के एक समूह के साथ जोड़ा जाता है, जो उनके सापेक्ष संभावनाओं द्वारा भारित हो सकते हैं।

आउटपुट फ़ंक्शन परिभाषा

L%"The universe contains %s.":j", "fT.e?bs[b\ h@Jk?tb\s"")0b",(?!.*,)"" and"

यह एक फ़ंक्शन को परिभाषित करता है y(b), जो ब्रह्मांड की वर्तमान स्थिति को इसके इनपुट के रूप में स्वीकार करता है। यह केवल कणों की संख्या की एक सूची है, जो उनके प्रकार द्वारा आदेशित है जैसा कि पिछले अनुभाग में वर्णित शब्दकोश स्ट्रिंग में परिभाषित किया गया है।

L%"x":j", "fT.e?bs[b\ h@Jk?tb\s"")0b",(?!.*,)"" and"   "x" -> format string, omitted for brevity
L                                                      Define a function, y(b)
             .e                     b                  Map each element of b with its index, k, using:
               ?b                 0                     Is b non zero? If not, 0, otherwise...
                   b                                      Particle count
                    \                                     Space
                      h@Jk                                Particle name (lookup in dictionary, then take 1st element)
                          ?tb\s""                        Trailing s if more than 1
                 s[              )                       Concatenate the above 4
           fT                                          Filter out the 0s
      j", "                                            Join on comma + space
     :                                                 Replace in the above...
                                    ",(?!.*,)"         ... the last comma...
                                              " and"   ... with "and"
 %"x"                                                  Insert the above into the format string

सिमुलेशन निष्पादन

K+Q*]Z24Ws<K4yK=+Z1Vs.em?>O1.0he@JkY,kOee@Jkb<K4IN XhNK_1 XRK1xLGeN;yK%"Simulation ended after %s yoctoseconds."cZT

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

यूनिवर्स इनिशियलाइज़ेशन

जैसा कि ब्रह्मांड की स्थिति में सूचकांक 0 पर कण हिग्स बोसोन है, ब्रह्मांड की प्रारंभिक स्थिति इनपुट संख्या की एक सरणी है जिसके बाद 24 शून्य हैं।

K+Q*]Z24   implicit: Q=eval(input())
  Q        Input number
   *]Z24   0 repeated 24 times
 +         Concatenate
K          Assign to K

अनुकरण पाश

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

Ws<H4yK=+Z1Vs.em?>O1.0he@JkY,kOee@Jkb<K4IN XhNK_1 XRK1xLGeN;   
 s<K4                                                          Take the sum of the first 4 particle counts
W                                                          ;   Loop until the above is 0
     yK                                                        Output the current universe state
       =+Z1                                                    Increment variable Z (initially 0)
             .e                      <K4                       Map each particle count, b, with its index, k, using:
               m                    b                            Map over the particle count using:
                        @JK                                        Look up the particle data
                      he                                           Get the decay probability
                  O1.0                                             Generate random float between 0 and 1
                ?>         Y                                       Has particle failed to decay? Empty array if so, otherwise...
                               ee@Jk                                 Get the particle decay choices
                              O                                      Choose one of them at random
                            ,k                                       Create a pair with the current particle index and the above
            s                                                  Combine into single nested list
           V                                                   For N in the above:
                                        IN                       If N is not empty:
                                           X  K                    Add to element in K...
                                            hN                     ... at the correct particle's index...
                                               _1                  ... -1
                                                      xLGeN        Get the index of each particle to be added to the universe
                                                                     (lookup using index in G, lowercase alphabet)
                                                  XRK1             Add 1 to the element in K at each of the indexes

अंतिम उत्पादन

जब कोई अस्थिर कण नहीं बचे तो अनुकरण समाप्त हो जाता है। ब्रह्मांड की अंतिम स्थिति का उत्पादन करना बाकी है, और सिमुलेशन ने कितने समय (कितने टिक) लिए।

yK%"Simulation ended after %s yoctoseconds."cZT   
yK                                                Output final universe state
                                            cZT   Float divide ticks count by 10
  %"Simulation ended after %s yoctoseconds."      Format string, implicit print
— सोक
स्रोत
23

C ++ ( 2420 , 2243 , 2353 , 1860 , 1822 * .9 = 1639.8)

ठीक है, तो यह शायद सबसे खराब कभी कोड गोल्फ सबमिशन है, लेकिन यह मेरा पहला है और मुझे मज़ा आया। मुझे लगता है कि यह भी काम करता है। :)

#include <iostream>
#include <list>
#include <string>
#include <time.h>
#define D r=rand();d=((double)r/RAND_MAX)
using namespace std;class P{int n[25];public:int S;P(int N){for(S=0;S<24;S++)n[S]=0;n[24]=N;S=1;}void C(){string s[25]={"down quark","down antiquark","up quark","up antiquark","bottom quark","bottom antiquark","tau lepton","antitau lepton","charm quark","charm antiquark","strange quark","strange antiquark","neutrino","antineutrino","muon","antimuon","gluon","photon","electron","positron","top quark","top antiquark","Z boson","W boson","Higgs boson"};int r,i,j,w,f,F,x,y;double d;S=0;F=0;for(i=0;i<25;i++){w=0;for(j=0;j<n[i];j++){D;x=-1;y=-1;if(i==24){if(d<.000433){D;if(d<.648){x=4;y=5;}else if(d<.789){x=23;y=23;}else if(d<.8772){x=16;y=16;}else if(d<.9476){x=6;y=7;}else if(d<.9803){x=8;y=9;}else if(d<.9962){x=22;y=22;}else if(d<.99843){x=17;y=17;}else if(d<.99954){x=22;y=17;}else if(d<.999784){x=14;y=16;}else{x=21;y=20;}}}else if(i==23){if(d<.5){D;if(d<.33){x=19;y=12;}else if(d<.67){x=16;y=12;}else{x=17;y=12;}}}else if(i==22){if(d<.5){D;if(d<.206){x=12;y=13;}else if(d<.24){x=18;y=19;}else if(d<.274){x=14;y=16;}else if(d<.308){x=16;y=17;}else if(d<.46){x=0;y=1;}else if(d<.612){x=10;y=11;}else if(d<.764){x=4;y=5;}else if(d<.882){x=2;y=3;}else{x=8;y=9;}}}else if(i==21||i==20){if(d<.1295){D;x=23;if(d<.33){y=0;}else if(d<.67){y=10;}else{y=4;}if(i==21)y-=32;}}if(x>=0){++n[x];++n[y];w++;}if(x>19||y>19)S=1;}n[i]-=w;if(n[i]>0){F=i;if(i>19)S=1;}}cout<<"The universe contains";f=0;for(i=0;i<25;i++){if(n[i]>0){cout<<(f>0?(i<F?", ":" and "):" ")<<n[i]<<' '<<s[i]<<(n[i]>1?"s":"");f=1;}}cout<<'.'<<endl;}};int main(int c,char* v[]){int w=1,y=0;if(c>1){w=atoi(v[1]);}srand(time(0));rand();P p=P(w);int Time=time(0);while(p.S){p.C();y++;}cout<<"Simulation ended after "<<(double)y/10<<" yoctoseconds.";}

तेज संस्करण

यह एक के रूप में कम (9 अतिरिक्त बाइट्स) नहीं है, लेकिन इसे चलाता तरह से बड़ी संख्या के परीक्षण के लिए तेजी से। चूंकि यह प्रतिस्पर्धा करने के लिए कम नहीं है, इसलिए मैंने वास्तविक दुनिया के निष्पादन के समय को देखने के लिए एक छोटा कोड भी जोड़ा और सही समय के बाद इसे प्रिंट किया। मेरे मूल संस्करण ने लगभग 8 मिनट में n = 100k किया। उपरोक्त संस्करण लगभग 2 मिनट में करता है। यह तेज संस्करण 9 सेकंड में कर सकता है। n = 1 मिलियन ने 53 सेकंड का समय लिया।

#include <iostream>
#include <list>
#include <string>
#include <time.h>
#define D r=rand();d=((double)r/RAND_MAX)
using namespace std;class P{int n[25];public:int S;P(int N){for(S=0;S<24;S++)n[S]=0;n[24]=N;S=1;}void C(){string s[25]={"down quark","down antiquark","up quark","up antiquark","bottom quark","bottom antiquark","tau lepton","antitau lepton","charm quark","charm antiquark","strange quark","strange antiquark","neutrino","antineutrino","muon","antimuon","gluon","photon","electron","positron","top quark","top antiquark","Z boson","W boson","Higgs boson"};int r,i,j,w,f,F,x,y;double d;S=0;F=0;for(i=20;i<25;i++){w=0;for(j=0;j<n[i];j++){D;x=-1;y=-1;if(i==24){if(d<.000433){D;if(d<.648){x=4;y=5;}else if(d<.789){x=23;y=23;}else if(d<.8772){x=16;y=16;}else if(d<.9476){x=6;y=7;}else if(d<.9803){x=8;y=9;}else if(d<.9962){x=22;y=22;}else if(d<.99843){x=17;y=17;}else if(d<.99954){x=22;y=17;}else if(d<.999784){x=14;y=16;}else{x=21;y=20;}}}else if(i==23){if(d<.5){D;if(d<.33){x=19;y=12;}else if(d<.67){x=16;y=12;}else{x=17;y=12;}}}else if(i==22){if(d<.5){D;if(d<.206){x=12;y=13;}else if(d<.24){x=18;y=19;}else if(d<.274){x=14;y=16;}else if(d<.308){x=16;y=17;}else if(d<.46){x=0;y=1;}else if(d<.612){x=10;y=11;}else if(d<.764){x=4;y=5;}else if(d<.882){x=2;y=3;}else{x=8;y=9;}}}else if(i==21||i==20){if(d<.1295){D;x=23;if(d<.33){y=0;}else if(d<.67){y=10;}else{y=4;}if(i==21)y-=32;}}if(x>=0){++n[x];++n[y];w++;}if(x>19||y>19)S=1;}n[i]-=w;if(n[i]>0&&i>19)S=1;}for(i=0;i<25;i++){if(n[i]>0)F=i;}cout<<"The universe contains";f=0;for(i=0;i<25;i++){if(n[i]>0){cout<<(f>0?(i<F?", ":" and "):" ")<<n[i]<<' '<<s[i]<<(n[i]>1?"s":"");f=1;}}cout<<'.'<<endl;}};int main(int c,char* v[]){int w=1,y=0;if(c>1){w=atoi(v[1]);}srand(time(0));rand();P p=P(w);int Time=time(0);while(p.S){p.C();y++;}cout<<"Simulation ended after "<<(double)y/10<<" yoctoseconds.";cout<<endl<<"Time Taken: "<<(time(0)-Time)<<" seconds."<<endl;}

नमूना उत्पादन (कोई args)

The universe contains 1 Higgs boson.
... (many lines later)
The universe contains 1 Higgs boson.
The universe contains 1 bottom quark and 1 bottom antiquark.
Simulation ended after 339.4 yoctoseconds.

नमूना उत्पादन (ब्रह्मांड। 10):

The universe contains 10 Higgs bosons.
The universe contains 1 bottom quark, 1 bottom antiquark and 9 Higgs bosons.
The universe contains 2 bottom quarks, 2 bottom antiquarks and 8 Higgs bosons.
The universe contains 3 bottom quarks, 3 bottom antiquarks and 7 Higgs bosons.
The universe contains 4 bottom quarks, 4 bottom antiquarks and 6 Higgs bosons.
The universe contains 4 bottom quarks, 4 bottom antiquarks, 1 charm quark, 1 charm antiquark and 5 Higgs bosons.
The universe contains 5 bottom quarks, 5 bottom antiquarks, 1 charm quark, 1 charm antiquark and 4 Higgs bosons.
The universe contains 5 bottom quarks, 5 bottom antiquarks, 1 charm quark, 1 charm antiquark, 2 Z bosons and 3 Higgs bosons.
The universe contains 5 bottom quarks, 5 bottom antiquarks, 1 charm quark, 1 charm antiquark, 1 neutrino, 1 antineutrino, 1 Z boson and 3 Higgs bosons.
The universe contains 5 bottom quarks, 5 bottom antiquarks, 1 charm quark, 1 charm antiquark, 2 neutrinos, 2 antineutrinos and 3 Higgs bosons.
The universe contains 6 bottom quarks, 6 bottom antiquarks, 1 charm quark, 1 charm antiquark, 2 neutrinos, 2 antineutrinos and 2 Higgs bosons.
The universe contains 7 bottom quarks, 7 bottom antiquarks, 1 charm quark, 1 charm antiquark, 2 neutrinos, 2 antineutrinos and 1 Higgs boson.
The universe contains 7 bottom quarks, 7 bottom antiquarks, 1 charm quark, 1 charm antiquark, 2 neutrinos, 2 antineutrinos and 2 W bosons.
The universe contains 7 bottom quarks, 7 bottom antiquarks, 1 charm quark, 1 charm antiquark, 2 neutrinos, 2 antineutrinos and 2 W bosons.
The universe contains 7 bottom quarks, 7 bottom antiquarks, 1 charm quark, 1 charm antiquark, 3 neutrinos, 2 antineutrinos, 1 photon and 1 W boson.
The universe contains 7 bottom quarks, 7 bottom antiquarks, 1 charm quark, 1 charm antiquark, 4 neutrinos, 2 antineutrinos, 1 gluon and 1 photon.
Simulation ended after 1160.5 yoctoseconds.

नमूना उत्पादन (ब्रह्मांड। 1000000)

(काफी 10 ^ 90 नहीं, लेकिन हम वहां पहुंच रहे हैं)

(about a minute, 14 MB and 33000 lines of output later)
The universe contains 5006 down quarks, 4945 down antiquarks, 3858 up quarks, 3858 up antiquarks, 653289 bottom quarks, 653190 bottom antiquarks, 70388 tau leptons, 70388 antitau leptons, 36449 charm quarks, 36449 charm antiquarks, 4956 strange quarks, 4873 strange antiquarks, 289364 neutrinos, 6764 antineutrinos, 1401 muons, 275514 gluons, 99433 photons, 1065 electrons and 94219 positrons.
Simulation ended after 3299.9 yoctoseconds.

बड़ा आउटपुट

यदि आप कमांड लाइन से कंसोल आउटपुट का उपयोग कर रहे हैं, तो मैं कुछ सुझाव universe.exe 100 > temp.txtदूंगा ताकि यह बहुत तेजी से आगे बढ़े। नोटपैड के साथ ++, आप तो खुला temp.txt, हिट कर सकते हैं ctrl+H, में प्रवेश ^(.*?)$\s+?^(?=.*^\1$)में खोजें क्या क्षेत्र, में कुछ भी नहीं दर्ज के साथ बदलें क्षेत्र, बारी खोज मोड के लिए Regular Expression, बारी चयन में और । न्यूलाइन से मेल खाता है OFF , फिर हिट होता है Replace All। अब आप बस यह देखते हैं कि आउटपुट की 8000 लाइनों के बजाय परिवर्तन कहां हुआ (मुझे लगता है कि बग्स एक समय में 2000-3000 से अधिक लाइनें कर रहे हैं)।

ठीक करता है / बदलाव

v4 - complete overhaul, removed list, one character array, moved almost everything into the class functions. Fixed output error, was using "," instead of "and" for last item. Sped up execution a *lot* as an added bonus. :)
v3 - more fixes
v2 - more shorter
v1 - fixed numerous little issues, bug fixes
v0 - baseline
— माइकल्स
स्रोत
1
यह आपके पहले उदाहरण में लगता है कि आपने ताऊ लीपटन को अप क्वार्क के साथ उलझा दिया। ताऊ लेप्टान में 10 ^ -13 सेकंड के आदेश पर एक आधा जीवन है, इसलिए इसे इस सिमुलेशन में स्थिर माना जाता है, अन्यथा हमारे पास कई अरबों लाइनें होती हैं जब तक कि यह सड़ न जाए। हमारे सिमुलेशन में क्षय करने वाली एकमात्र वस्तुएं हैं बोसोन, और शीर्ष क्वार्क / एंटिकार्क।
— 9
2
आप छोटा कर सकते हैं char t[N]={'d','D','u','U','b','B','l','L','c','C','s','S','n','N','m','M','g','G','p','e','E','T','t','Z','W','H'करने के लिए char t[]="dDuUbBlLcCsSnNmMgGpeETtZWH"? सी में काम करना चाहिए , सी ++ के
— डिजिटल ट्रॉमा
12

पायथन 3, 1,247 * 0.9 = 1,122.3

खैर, यह एक लंबे शॉट द्वारा मेरी सबसे लंबी प्रविष्टि है, लेकिन कम से कम मैं C ++ से छोटा हूं।

अब जोड़ा बोनस के साथ! इसे पहले तर्क के रूप में एक संख्या के साथ बुलाया जाना है।

मेरा ब्रह्मांड हिग्स बोसोन के अलावा अन्य क्षयकारी कणों के साथ काम नहीं करता था, लेकिन अब यह करता है। इसके अलावा, मेरे पास बहुवचन या विराम चिह्न सही नहीं था, लेकिन मैं वास्तव में अब करता हूं ।

मैं उप 1k के करीब हो रहा हूँ!

import random,sys,numpy as h
H,M,G,N,P,K,L,n,s='photon,muon,gluon,neutrino,positron, quark,tau lepton, boson,The universe '.split(',')
c=random.choice
Z=' anti'+K[1:]
B='bottom'+K
A=B[:6]+Z
U='anti '+M
T=U[:4]+L
Q='charm'+K
C=Q[:5]+Z
S='strange'+K
R=S[:7]+Z
D='down'+K
O=D[:4]+Z
def w(c):v,t=zip(*c);t=h.array(t);return v[h.random.choice(len(v),p=t/t.sum())]
y=M,U
f=lambda p:{z:w([(c([('up'+K,'up'+Z),(Q,C)]),11.8),((N,U[:5]+N),20.6),(c([('electron',P),y,(L,T)]),3.4),(c([(S,R),(B,B),(D,O)]),15.2)]),E:(I,c([D,S,B])),F:(I,c([O,R,A])),I:c([(P,N),(U,N),(T,N)]),J:w([((B,A),64.8),((I,I),14.1),((G,G),8.82),((L,T),7.04),((Q,C),3.27),((z,z),1.59),((H,H),0.223),((z,H),0.111),(y,0.0244),((E,F),0.0246)])}[p]
z='Z'+n,50
E='top'+K,12.95
F='top'+Z,E[1]
I='W'+n,50
J='Higgs'+n,.0433
u=[J]*int(sys.argv[1])
b={z,E,F,I,J}
k=isinstance
d=lambda p:p if k(p,str)else w([(p,100-p[1]),(f(p),p[1])])
a=0
g=lambda x:[x[0],x][k(x,str)]
while b&set(u):
 n=[]
 for p in u:q=d(p);n+=([q],(q,[q])[q in b])[p in b]
 e=list(map(g,n));e=[(x,x+'s')[e.count(x)>1]for x in e];print(s+'contains %s'%', '.join(('%s %s'%(e.count(x),g(x))for x in set(e[:-1])))+('.',' and %s %s.'%(e.count(e[-1]),e[-1]))[len(set(e))>1]);a+=.1;u=n
print(s+'ended after %s yoctoseconds.'%round(a,1))
— मॉर्गन थ्राप्प
स्रोत
11
मुझे लगता है कि यह मज़ेदार है कि ब्रह्मांड को अनुकरण करने वाला एक कार्यक्रम शुरू होता है import random। नियतत्ववाद के लिए बहुत कुछ।
— 21
यह python3 सही है? मुझे लगता है कि आप अंतिम प्रिंट में एफ-स्ट्रिंग्स का उपयोग कर सकते हैं , जो आपको 1 या 2 बाइट्स :-) बचा सकता है।
— क्रोमियम
1
@ क्रोमियम हाँ, मैं शायद कर सकता था। जब मैंने यह उत्तर लिखा था तब वे मौजूद नहीं थे, लेकिन मैं निश्चित रूप से वापस जा सकता था और उन्हें जोड़ सकता था।
— मॉर्गन थ्रैप
11

पर्ल 6 , (707 बाइट्स -10%) स्कोर 636.3

थोड़ी अधिक पठनीयता के लिए कुछ अनावश्यक लाइन टूटने के साथ:

{
 my%p;
 %p=<H H2309.469bB64.8WW14.1gg8.82lL7.04cC3.27ZZ1.59pp0.223Zp0.111mM0.0244tT0.0216 W W3pn1Mn1Ln1 Z Z100nN20.6ep3.4mM3.4lL3.4dD15.2sS15.2bB15.2uU11.8cC11.8 t t7.722Wd1Ws1Wb1 T T7.722WD1WS1WB1>;
 my&f=*.comb[0];

 my%h;
 %h{.&f}="$_ boson" for <Higgs W Z>;
 {
  %h{.&f}="$_ quark";
  %h{.&f.uc}="$_ antiquark"
 } for <bottom top charm up down strange>;
 %h{.&f}=$_~"on" for <glu phot electr positr>;
 %h{.&f.uc}="anti"~(%h{.&f}=$_) for <muon neutrino>;
 %h<L>="anti"~(%h<l>="tau lepton");

 my$t;
 ("H"x$^a),{
   $t+=.1;
   S:g/./{%((%p{$/}||$/~1).comb(/(\D+|<:!L>+)/)).Mix.roll}/
 }...{
   say "The universe contains {
      .comb.Bag.map({
         "{.value,%h{.key}~'s'x(.value>1)}"
      }).join(', ')
   }.";
   !/<[HWZtT]>/
 };
 say "Simulation ended after $t yoctoseconds."
}

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

The universe contains 4 Higgs bosons.
The universe contains 4 Higgs bosons.
The universe contains 4 Higgs bosons.
The universe contains 4 Higgs bosons.
The universe contains 3 Higgs bosons, 2 gluons.
The universe contains 3 Higgs bosons, 2 gluons.
The universe contains 3 Higgs bosons, 2 gluons.
The universe contains 3 Higgs bosons, 2 gluons.
The universe contains 3 Higgs bosons, 2 gluons.
The universe contains 3 Higgs bosons, 2 gluons.
The universe contains 3 Higgs bosons, 2 gluons.
The universe contains 3 Higgs bosons, 2 gluons.
The universe contains 1 tau lepton, 2 Higgs bosons, 2 gluons, 1 antitau lepton.
The universe contains 1 tau lepton, 2 Higgs bosons, 2 gluons, 1 antitau lepton.
The universe contains 1 tau lepton, 2 Higgs bosons, 2 gluons, 1 antitau lepton.
The universe contains 1 tau lepton, 2 Higgs bosons, 2 gluons, 1 antitau lepton.
The universe contains 1 tau lepton, 1 Higgs boson, 4 gluons, 1 antitau lepton.
The universe contains 1 tau lepton, 6 gluons, 1 antitau lepton.
Simulation ended after 1.7 yoctoseconds.

कुछ स्पष्टीकरण: भगवान और मनुष्य

भौतिकी %pऔर नामकरण धारण करने वाले 2 डेटा संरचनाएं हैं %h; देवता और मनुष्य जैसा भी था। भौतिकी हैश मूल अस्थिर कण पत्र द्वारा अनुक्रमित तार का एक सेट देता है, जिसे विभाजित किया जा सकता है, हैश और एक मिक्स में परिवर्तित किया जा सकता है:

say %((%p<H>).comb(/(\D+|<:!L>+)/)).Mix;
> Mix(H(2309.469), WW(14.1), ZZ(1.59), Zp(0.111), bB(64.8), cC(3.27), gg(8.82), lL(7.04), mM(0.0244), pp(0.223), tT(0.0216))

प्रत्येक कण को ​​एक पत्र मिलता है, और इस प्रकार इनमें से प्रत्येक मिश्रण कण के क्षय का एक संग्रह निर्दिष्ट करता है। H, WW की संभावना 14.1 है। कण-कण जोड़े कम और बड़े अक्षरों, जैसे के साथ कोडित रहे हैं cऔर Cआकर्षण क्वार्क और आकर्षण क्वार्क के लिए।

और आदमी ने थोड़ा सोचा, और इसका नाम एंटीटा लेप्टन रखा

नामकरण सभी में सेट किया गया है %h, जो बस प्रत्येक अक्षर को एक कण नाम में मैप करता है। यह एक हद तक गॉल्फर्ड है, लेकिन मुझे संदेह है कि सुधार की गुंजाइश है क्योंकि वहां पुनरावृत्ति की राशि दी गई है।

p => positron
g => gluon
Z => Z boson
B => bottom antiquark
e => electron
s => strange quark
d => down quark
W => W boson
m => muon
U => up antiquark
c => charm quark
H => Higgs boson
L => antitau lepton
N => antineutrino
n => neutrino
S => strange antiquark
D => down antiquark
T => top antiquark
u => up quark
t => top quark
b => bottom quark
M => antimuon
C => charm antiquark
l => tau lepton

मूल तार

उन दो संरचनाओं के साथ, ब्रह्मांड को सिम्युलेटेड किया गया है, ज़ाहिर है, स्ट्रिंग हेरफेर द्वारा। तो "H"एक ब्रह्मांड है जिसमें एक एकल हिग्स बोसोन है। जनरेटर संरचना _,_..._का उपयोग लूप बनाने के लिए किया जाता है, और $_इसे प्रिंट करने से ब्रह्मांड स्ट्रिंग (आयोजित ) की अवस्था को विकसित करने को अलग करता है। ब्रह्माण्ड में अक्षरों को बांधने और परिणामस्वरूप गिनाई (बहुवचन के साथ!) को मैप करके छपाई की जाती है।

में छींकने वाले कण

विकसित कणों में उस कण के लिए मिक्स से उठाए गए मूल्य के लिए उन्हें मैप करना शामिल है; इसलिए t, शीर्ष क्वार्क, विकसित होता है

t=>7.722
Wd=>1
Ws=>1
Wb=>1

Perl6 हमें बेतरतीब ढंग से फर्श के माध्यम से दिए गए भार के साथ उन चाबियों में से एक को चुनने की अनुमति देता है .roll। इसलिए हम अपने ब्रह्मांड "एचटीटी" -> "एचडब्ल्यूबीटी" में इसे tप्राप्त करने, कहने Wbऔर प्रतिस्थापित करने के लिए रोल करते हैं । प्रत्येक अस्थिर कण के पास एक संभावित रोल के रूप में होता है, जो हमें संरचना को सरल बनाने की अनुमति देता है बनाम यह जांचने के लिए कि क्या यह क्षय हुआ है या नहीं; अधिकांश समय जब आप "एच" के लिए रोल करते हैं, तो आपको बस "एच" फिर से मिलता है।

प्रायोगिक स्ट्रिंग सिद्धांत

आप इस संशोधित संस्करण के माध्यम से ब्रह्मांड स्ट्रिंग को विकसित होते हुए देख सकते हैं ।

 HHH
 HHH
 HHbB
 HHbB
 HHbB
 HHbB
 HHbB
 HHbB
 lLHbB
 lLHbB
 lLHbB
 lLHbB
 lLHbB
 lLbBbB

प्रदर्शन

मैंने इसे TIO पर 100 H के रूप में लिया है, अनिवार्य रूप से यदि आप बहुत आगे जाना चाहते हैं तो कुछ बदलाव करना बेहतर होगा, यह सब के बाद ग्रैंड यूनिफाइड स्ट्रिंग थ्योरी है।

— फिल एच
स्रोत
उस आदमी को क्या नाम दिया, फिल?
— मनोज कुमार
1
@ManojKumar: विकिपीडिया के अनुसार: "प्रतीक derived ग्रीक τρίτον (ट्राइटन, जिसका अर्थ अंग्रेजी में" तीसरा ") से लिया गया था, क्योंकि यह तीसरी चार्ज की गई लिप्टन थी।" ( en.wikipedia.org/wiki/Tau_(particle) )
— फिल एच।
7

ग्रूवी, 1506 1454 - 10% = 1309 बाइट्स

कमांड लाइन पर पहले तर्क के रूप में हिग्स बोसॉन कणों को शुरू करने की संख्या मान ली गई है: 

A='anti'
B='bottom '
C='charmed '
D='downward'
E='tau '
F='top '
L='lepton'
M='muon'
N='nutrino'
O=' boson'
P='upward '
Q='quark'
T='strange '
a=[n:'gluon']
b=[n:B+Q]
c=[n:B+A+Q]
d=[n:D+Q]
e=[n:D+A+Q]
f=[n:P+Q]
g=[n:P+A+Q]
h=[n:T+Q]
i=[n:T+A+Q]
j=[n:C+Q]
k=[n:C+A+Q]
l=[n:'positron']
m=[n:'electron']
n=[n:N]
o=[n:A+N]
p=[n:'photon']
q=[n:M]
r=[n:A+M]
s=[n:E+L]
t=[n:A+E+L]
u=[n:'W'+O,c:50,s:[[c:33,p:[l,n]],[c:33,p:[l,n]],[c:33,p:[l,n]]]]
v=[n:F+Q,c:12.95,s:[[c:33,p:[u,d]],[c:33,p:[u,h]],[c:33,p:[u,b]]]]
w=[n:F+A+Q]
x=[n:'Z'+O,c:50,s:[[c:20.6,p:[n,o]],[c:3.4,p:[m,l]],[c:3.4,p:[q,r]],[c:3.4,p:[s,t]],[c:15.2,p:[d,e]],[c:15.2,p:[h,i]],[c:15.2,p:[b,c]],[c:11.8,p:[f,g]],[c:11.8,p:[j,k]]]]
y=[n:'Higgs'+O,c:0.0433,s:[[c:64.8,p:[b,c]],[c:14.1,p:[u,u]],[c:8.82,p:[a,a]],[c:7.04,p:[s,t]],[c:3.27,p:[j,k]],[c:1.59,p:[x,x]],[c:0.223,p:[p,p]],[c:0.111,p:[x,l]],[c:0.0244,p:[q,r]],[c:0.0216,p:[v,w]]]]
O={new Random().nextInt(1000001)/10000}
S={s,c->for(Map p:s){c-=p.c;if(c<=0){return p.p}};S(s,O())}
P={r=[];it.collect{it.n}.groupBy{it}.each{k,v->c=v.count{it};r<<"${c} ${c>1?k+'s':k}"};r.join(', ').reverse().replaceFirst(',', 'dna ').reverse()}
U=[]
args[0].times{U<=O()){I.remove();S(J.s,O()).each{I.add(it)}}}
if(!Z){println "Simulation ended after $Y yoctoseconds.";break}}

— के। क्लासेन
स्रोत
1454 का 10% 145.4 है
— geokavel
गणित के साथ ऐसा लगता है कि एक आश्चर्य सिमुलेशन सभी पर काम करता है :-) यह इंगित करने के लिए धन्यवाद!
— । क्लासेन
7

PHP, 989 - 10% = 890.1 बाइट्स

उप 1K बच्चे! धन्यवाद vsz, यह वास्तव में एक मजेदार चुनौती थी। इसके बारे में जाने के लिए बहुत सारे तरीके और अपने आउटपुट को सत्यापित करने के लिए बहुत मुश्किल है।

कार्यक्रम उदाहरण के लिए हिग्स बोसोन की शुरुआती संख्या निर्दिष्ट करने के लिए कमांड लाइन तर्क ले सकता है php universe_simulator.php 5

<?eval(gzinflate(base64_decode('bVNdb9Q6EH3nV4TVSEm0ozRpt/uBcRGlQLlw4QIFWqxQuYm7mza1s4mzdEH73+84WUqFyINzjn1mfMaaAcmltgWDC35hrDU3DDKeLWRN4JC2GqMZLPmylfU1g4Y3tpZ6rhhY7lvZeqWqrNE+A821am1daMMuTa1ktgjUbVWaXAU++jiAn3Jz0xqNIKFbLMKFR/9l96c127LMsdx81z3v0RJVqTJbU4J56dIcF/N548Eh9kk1VgtDTrAyTdHJoNnma7rsFq2p+p0OLLHd0rZjX1yur7QMQtnAKoRKZIs6GA6hGI5HYcphxSDn4g0/EFEcx6O9PRQiGo+mKI7weZqiiCbTGYpTPO3IdDLZRfEaX3dsNpqMUTzDjz2bxhT9Al/2bDYm5Rmebdl0RIfv8N2WzvZHjv46nU2mxJ/iv44nKE7wU0ofnjpj++Qp2aHwt/ifO991+Cm+3WqfOUT47Jc22o3J1mEviPb2qZhjfNWRfdK/xw8dHjuDv6tE8Rm/9EXOpvfq2CPVP/3F0Ww8vu+yq5zwJ3dzsju7M/qqf67O6Icek/y5Q4RP/pQf35O/v5Mf9fKUQctlXcv1+WVRlkFMfVbPVyJJnzxK8E3IYM1j9n1RlCp4CLfhT7jlCYMrLtK7pu3DM9Nqe76SZauaAFrXEtf8wLXFlUj5AFYe9Qdcp4MogNVB8sRv/Ee+HzKVLYxX1Wp+XquqlBk1/w4G4humwxB2aBA8qXNIaB5OFsprdbFSdaO8zGgrC914g+jKFJomxvMRrsJoED0YhHfeoPXISEFGbFhcBpALsGlXRcyI02TmQbgzV25G8xt5G4SPeS8SsdP94H+R/M7eK5OU7si6/D8oPOtC+1ep2saZwCiKaD9JQ3ZBodds0+pGWToRUNDmZgPrIY8StnHPMfhY3LSltIXRntK5yj15aVXtwdpbm8yaRlH1eUOFsv8B')));

यहाँ लाइन ब्रेक के साथ एक ही बात है, उह ... "पठनीयता" ...

<?eval(gzinflate(base64_decode('bVNdb9Q6EH3nV4TVSEm0ozRpt/uBcRGlQLlw4QIFWqxQuYm7
mza1s4mzdEH73+84WUqFyINzjn1mfMaaAcmltgWDC35hrDU3DDKeLWRN4JC2GqMZLPmylfU1g4Y3tpZ6
rhhY7lvZeqWqrNE+A821am1daMMuTa1ktgjUbVWaXAU++jiAn3Jz0xqNIKFbLMKFR/9l96c127LMsdx8
1z3v0RJVqTJbU4J56dIcF/N548Eh9kk1VgtDTrAyTdHJoNnma7rsFq2p+p0OLLHd0rZjX1yur7QMQtnA
KoRKZIs6GA6hGI5HYcphxSDn4g0/EFEcx6O9PRQiGo+mKI7weZqiiCbTGYpTPO3IdDLZRfEaX3dsNpqM
UTzDjz2bxhT9Al/2bDYm5Rmebdl0RIfv8N2WzvZHjv46nU2mxJ/iv44nKE7wU0ofnjpj++Qp2aHwt/if
O991+Cm+3WqfOUT47Jc22o3J1mEviPb2qZhjfNWRfdK/xw8dHjuDv6tE8Rm/9EXOpvfq2CPVP/3F0Ww8
vu+yq5zwJ3dzsju7M/qqf67O6Icek/y5Q4RP/pQf35O/v5Mf9fKUQctlXcv1+WVRlkFMfVbPVyJJnzxK
8E3IYM1j9n1RlCp4CLfhT7jlCYMrLtK7pu3DM9Nqe76SZauaAFrXEtf8wLXFlUj5AFYe9Qdcp4MogNVB
8sRv/Ee+HzKVLYxX1Wp+XquqlBk1/w4G4humwxB2aBA8qXNIaB5OFsprdbFSdaO8zGgrC914g+jKFJom
xvMRrsJoED0YhHfeoPXISEFGbFhcBpALsGlXRcyI02TmQbgzV25G8xt5G4SPeS8SsdP94H+R/M7eK5OU
7si6/D8oPOtC+1ep2saZwCiKaD9JQ3ZBodds0+pGWToRUNDmZgPrIY8StnHPMfhY3LSltIXRntK5yj15
aVXtwdpbm8yaRlH1eUOFsv8B')));

कुछ आउटपुट:

The universe contains 2 Higgs bosons.
[...]
The universe contains 1 Higgs boson, 2 neutrinos, 1 positron and 1 antimuon.
The universe contains 1 Higgs boson, 2 neutrinos, 1 positron and 1 antimuon.
The universe contains 1 Higgs boson, 2 neutrinos, 1 positron and 1 antimuon.
The universe contains 1 Higgs boson, 2 neutrinos, 1 positron and 1 antimuon.
The universe contains 1 Higgs boson, 2 neutrinos, 1 positron and 1 antimuon.
The universe contains 2 neutrinos, 1 positron, 1 antimuon, 1 bottom antiquark and 1 bottom quark.
Simulation ended after 153.2 yoctoseconds.
— एलेक्स हॉन्सस्की
स्रोत
5
तुम भी जवाब करने के लिए असम्पीडित संस्करण जोड़ सकते हैं?
— रे
"पठनीयता!" अनजिप संस्करण?
— मनोज कुमार
7

QBasic 2161 * .9 = 1945 2028 * .9 = 1825 1854 * .9 = 1669 बाय।

अब जब QBasic LOTM है, तो मुझे लगा कि मैं PPCG पर अपना पहला उत्तर कभी संशोधित करूंगा। 140 बाइट्स नॉक करने में कामयाब, खराब नहीं!

@TaylorScott और @DLosc द्वारा प्रतिक्रिया के आधार पर मैंने एक पूर्ण रीडिज़ाइन किया है:

  • समय बदल रहा है
  • स्वरूपण अब कल्पना के अनुरूप है
  • अनुक्रमित स्ट्रिंग में एक सरणी बनाकर एक टन बाइट्स की बचत की

कोड

SUB f(p$,c)
DIM e$(25)
q$=" quark
a$=" antiquark
e$(1)="HHiggs boson
e$(2)="bbottom"+q$
e$(3)="1bottom"+a$
e$(4)="WW boson
e$(5)="gGluon
e$(6)="TTau lepton
e$(7)="2Tau antilepton
e$(8)="ccharm"+q$
e$(9)="3charm"+a$
e$(10)="ZZ boson
e$(11)="pphoton
e$(12)="mmuon
e$(13)="4antimuon
e$(14)="0top"+q$
e$(15)="5top"+a$
e$(16)="+positron
e$(17)="nneutrino
e$(18)="6antineutrino
e$(19)="-electron
e$(20)="ddown"+q$
e$(21)="7down"+a$
e$(22)="sstrange"+q$
e$(23)="8strange"+a$
e$(24)="uup"+q$
e$(25)="9up"+a$
FOR i=1TO 25
IF LEFT$(e$(i),1)=p$THEN ?str$(c)" "MID$(e$(i),2);
NEXT
IF c>1THEN?"s";
END SUB
RANDOMIZE TIMER
z=100
INPUT x
p$=string$(x,"H")
1:b=0
REDIM m$(LEN(p$))
FOR i=1TO LEN(p$)
m$(i)=MID$(p$,i,1)
NEXT
p$=s$(m$())
t=t+1
?"The universe contains";
FOR i=1TO LEN(p$)
y$=MID$(p$,i,1)
z$=MID$(p$,i+1,1)
c=c+1
IF(y$=z$ AND i<LEN(p$))=0THEN f y$,c:c=0
NEXT
?
r$="
FOR i=1TO LEN(p$)
d&=(RND*z)*z
e&=(RND*z)*(z^2)
q$=MID$(p$,i,1)
IF INSTR("HWZ02",q$) THEN b=1
r$=r$+g$(d&,e&,q$)
NEXT
p$=r$
IF b GOTO 1
?"Simulation ended after"t/10"yoctoseconds.
FUNCTION g$(d&,p&,q$)
DIM e$(28)
FOR i=1TO 28
x$=Mid$("H00433099979405H004330999550m4H004330998440ZpH004330996210ppH004330980310ZZH004330947610c3H004330877210T2H004330789010ggH004330648010WWH004330000000b12012950666670W12012950333340W82012950000000W70012950666670Wb0012950333340Ws0012950000000WdW0500006666702nW0500003333404nW050000000000+nZ050000882010c3Z050000764010u9Z050000612010b1Z050000460010s8Z050000308010d7Z050000274010T2Z050000240010m4Z050000206010-+Z050000000000n6",15*i+1,15)
a&=VAL(MID$(x$,8,7))
g$=q$
IF LEFT$(x$,1)=q$ THEN
IF d&<VAL(MID$(x$,2,5)) THEN
IF(p&>a& OR a&=0) THEN
g$=RIGHT$(x$,2)
EXIT FUNCTION
ENDIF
ENDIF
ENDIF
NEXT
END FUNCTION
FUNCTION s$(n$())
x=UBOUND(n$)
FOR i=1TO x:FOR J=1TO x
IF n$(i)<n$(J)THEN SWAP n$(i),n$(J)
NEXT j,i
FOR i=1TO UBOUND(n$)
a$=a$+n$(i)
NEXT
s$=a$
END FUNCTION

नमूना उत्पादन

? 3
The universe contains 3 Higgs bosons
The universe contains 3 Higgs bosons
The universe contains 3 Higgs bosons
The universe contains 3 Higgs bosons
The universe contains 1 bottom antiquark 2 Higgs bosons 1 bottom quark
The universe contains 1 bottom antiquark 2 Higgs bosons 1 bottom quark
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 2 bottom antiquarks 1 Higgs boson 2 bottom quarks
The universe contains 3 bottom antiquarks 3 bottom quarks
Simulation ended after 2.3 yoctoseconds.
— steenbergh
स्रोत
साल बाद गोल्फ के लिए याय ... लेकिन आउटपुट स्वरूपण प्रश्न में सख्त आवश्यकताओं से मेल नहीं खाता है। ??
— DLosc
1
के लिए - ~ 200 बाइट्स, उपयोग करें For i=0To 28 x$=Mid$("H00433099979405H004330999550m4H004330998440ZpH004330996210ppH004330980310ZZH004330947610c3H004330877210T2H004330789010ggH004330648010WWH004330000000b12012950666670W12012950333340W82012950000000W70012950666670Wb0012950333340Ws0012950000000WdW0500006666702nW0500003333404nW050000000000+nZ050000882010c3Z050000764010u9Z050000612010b1Z050000460010s8Z050000308010d7Z050000274010T2Z050000240010m4Z050000206010-+Z050000000000n6",15*i+1,15)... Nextसमारोह f$()में सरणी परe$()
— टेलर स्कॉट
फ़ंक्शन में s$(), Next:Nextहो सकता है Next j,i, और आपको यह देखने के लिए जांचना चाहिए कि क्या ?बयानों को उन सभी की आवश्यकता है ;। लेकिन यह भी प्रतीत होता है कि आपका आउटपुट वर्तमान में कल्पना से नहीं मिलता है
— टेलर स्कॉट
@ डलास और टेलर मैं आने वाले सप्ताहांत में आपके दोनों सुझावों को देखूंगा; मैं तब से पहले थोड़ा व्यस्त हूँ ... धन्यवाद।
— स्टैनबर्ग
6

सी # 6, 3619 3617 3611 3586 - 10% = 3227.4 बाइट्स

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

using System;using System.Collections.Generic;class a{List<P>L;List<Q>S;double Y;static void Main(string[]a){a b;b=a.Length<1?new a():a.Length<2?new a(int.Parse(a[0])):new a(int.Parse(a[0]),int.Parse(a[1]));}a(int j=1,int e=1){Random r=new Random(e);L=new List<P>();S=new List<Q>();for(int i=0;i<j;i++)L.Add(new H());while(L.Count>0){List<P>l=new List<P>();foreach(P p in L){List<P>d=p.C(r);if(d!=null)foreach(P y in d){if(y.GetType()==typeof(Q))S.Add((Q)y);else l.Add((P)y);}else l.Add(p);}L=l;Y+=.1;W();}var s=$"Simulation ended after {Y} yoctosecond";if(Y!=1d)s+="s";Console.WriteLine(s+".");}void W(){var t="";Dictionary<string,int>N=new Dictionary<string,int>();int M=0;foreach(P x in L){t=x+"";if(N.ContainsKey(t))N[t]++;else{N.Add(t,1);M++;}}foreach(Q x in S){t=x+"";if(N.ContainsKey(t))N[t]++;else{N.Add(t,1);M++;}}var o="The universe contains ";int i=N.Keys.Count;foreach(var x in N.Keys){i--;if(M==1){o+=$"{N[x]} {x}";if(N[x]!=1)o+="s";}else if(M==2){o+=$"{N[x]} {x}";if(N[x]!=1)o+="s";if(i!=0)o+=" and ";}else{if(i<1){o+=$"and {N[x]} {x}";if(N[x]!=1)o+="s";}else{o+=$"{N[x]} {x}";if(N[x]!=1)o+="s";o+=", ";}}}Console.WriteLine(o+".");}}abstract class P{public static string[]Z=new string[]{"photon","gluon","positron","electron","quark","lepton","muon","neutrino"};public double l;public abstract List<P>D(Random r);public List<P>C(Random r){List<P>d=null;if(r.NextDouble()<l)d=D(r);return d;}}class H:P{public H(){l=.000433;}public override List<P>D(Random r){var d=new List<P>();Action<P>U=d.Add;var n=r.NextDouble();if(n<.648){U(new Q("bottom "+Z[4]));U(new Q("bottom anti"+Z[4]));}else if(n<.789){U(new W());U(new W());}else if(n<.8772){U(new Q(Z[1]));U(new Q(Z[1]));}else if(n<.9476){U(new Q("tau "+Z[5]));U(new Q("antitau "+Z[5]));}else if(n<.9803){U(new Q("charm "+Z[4]));U(new Q("charm anti"+Z[4]));}else if(n<.9962){U(new Z());U(new Z());}else if(n<.99843){U(new Q(Z[0]));U(new Q(Z[0]));}else if(n<.99954){U(new Z());U(new Q(Z[0]));}else if(n<.999784){U(new Q(Z[6]));U(new Q("anti"+Z[6]));}else{U(new T(0>1));U(new T(1>0));}return d;}public override string ToString(){return"Higgs Boson";}}class W:P{public W(){l=.5;}public override List<P> D(Random r){var d=new List<P>();var n=r.NextDouble();d.Add(new Q(Z[7]));if(n<1/3d)d.Add(new Q(Z[2]));else if(n<2/3d)d.Add(new Q("anti"+Z[6]));else d.Add(new Q("antitau "+Z[5]));return d;}public override string ToString(){return"W Boson";}}class Z:P{public Z(){l=.5;}public override List<P>D(Random r){var d=new List<P>();var n=r.NextDouble();Action<P>U=d.Add;var t=Z[4];if(n<.206){U(new Q(Z[7]));U(new Q("anti"+Z[7]));}else if(n<.24){U(new Q(Z[3]));U(new Q(Z[2]));}else if(n<.274){U(new Q(Z[6]));U(new Q("anti"+Z[6]));}else if(n<.308){U(new Q("tau "+Z[5]));U(new Q("antitau "+Z[5]));}else if(n<.46){U(new Q("down "+t));U(new Q("down anti"+t));}else if(n<.612){U(new Q("strange "+t));U(new Q("strange anti"+t));}else if(n<.764){U(new Q("bottom "+t));U(new Q("bottom anti"+t));}else if(n<.882){U(new Q("up "+t));U(new Q("up anti"+t));}else{U(new Q("charm "+t));U(new Q("charm anti"+t));}return d;}public override string ToString(){return"Z Boson";}}class T:P{bool A;public T(bool a){A=a;l=.1295;}public override List<P>D(Random r){var d=new List<P>();var n=r.NextDouble();d.Add(new W());if(n<1/3d)d.Add(new Q("down "+Z[4]));else if(n <2/3.0)d.Add(new Q("strange "+Z[4]));else d.Add(new Q("bottom "+Z[4]));return d;}public override string ToString(){var r=A?"top anti":"top ";return r+Z[4];}}class Q:P{string N;public Q(string n){N=n;}public override List<P>D(Random r){return null;}public override string ToString(){return N;}}

मुझे इसके लिए वस्तुओं का उपयोग नहीं करना चाहिए था, मैं संभवतः इसके बजाय सरणियों का उपयोग करके एक दूसरा समाधान करने की कोशिश करूंगा, लेकिन यह संभवतः पहले से पोस्ट किए गए C ++ समाधान के समान होगा। हिग्स बोसोन मैं संभाल सकता है की संख्या गंभीर रूप से सीमित है, मुझे लगता है कि एच = 1,000,000 के लिए कम से कम एक घंटा है। छोटे संख्या हालांकि अच्छी तरह से चलते हैं।

नमूना उत्पादन:

$ b
// Default h=1,seed=1
The universe contains 1 Higgs Boson.
...
The universe contains 1 bottom quark and 1 bottom antiquark.
Simulation ended after 65.5000000000006 yoctosecond.

$ b 10 12345
The universe contains 10 Higgs Bosons.
The universe contains 9 Higgs Bosons, 1 bottom quark, and 1 bottom antiquark.
The universe contains 8 Higgs Bosons, 2 W Bosons, 1 bottom quark, and 1 bottom antiquark.
The universe contains 8 Higgs Bosons, 1 bottom quark, 1 bottom antiquark, 2 neutrinos, and 2 antitau leptons.
The universe contains 7 Higgs Bosons, 2 bottom quarks, 2 bottom antiquarks, 2 neutrinos, and 2 antitau leptons.
The universe contains 6 Higgs Bosons, 3 bottom quarks, 3 bottom antiquarks, 2 neutrinos, and 2 antitau leptons.
The universe contains 5 Higgs Bosons, 4 bottom quarks, 4 bottom antiquarks, 2 neutrinos, and 2 antitau leptons.
The universe contains 2 W Bosons, 4 Higgs Bosons, 4 bottom quarks, 4 bottom antiquarks, 2 neutrinos, and 2 antitau leptons.
The universe contains 1 W Boson, 4 Higgs Bosons, 4 bottom quarks, 4 bottom antiquarks, 3 neutrinos, 2 antitau leptons, and 1 antimuon.
The universe contains 4 Higgs Bosons, 4 bottom quarks, 4 bottom antiquarks, 4 neutrinos, 2 antitau leptons, and 2 antimuons.
The universe contains 3 Higgs Bosons, 5 bottom quarks, 5 bottom antiquarks, 4 neutrinos, 2 antitau leptons, and 2 antimuons.
The universe contains 2 Higgs Bosons, 6 bottom quarks, 6 bottom antiquarks, 4 neutrinos, 2 antitau leptons, and 2 antimuons.
The universe contains 1 Higgs Boson, 2 W Bosons, 6 bottom quarks, 6 bottom antiquarks, 4 neutrinos, 2 antitau leptons, and 2 antimuons.
The universe contains 1 Higgs Boson, 1 W Boson, 6 bottom quarks, 6 bottom antiquarks, 5 neutrinos, 2 antitau leptons, and 3 antimuons.
The universe contains 1 Higgs Boson, 6 bottom quarks, 6 bottom antiquarks, 6 neutrinos, 2 antitau leptons, 3 antimuons, and 1 positron.
The universe contains 7 bottom quarks, 7 bottom antiquarks, 6 neutrinos, 2 antitau leptons, 3 antimuons, and 1 positron.
Simulation ended after 540.500000000054 yoctoseconds.

मैं h = 1000000 रन के लिए अंतिम दो पंक्तियों को पोस्ट करूंगा जब यह पूरा हो जाएगा, शायद आज बाद में। वादे के अनुसार:

$ b 1000000
(a few hours, 35K lines, and 15MB later)
The universe contains 653391 bottom quarks, 653271 bottom antiquarks, 36336 charm quarks, 36336 charm antiquarks, 176724 gluons, 71397 tau leptons, 165604 antitau leptons, 5626 photons, 288869 neutrinos, 95047 positrons, 95556 antimuons, 5254 strange quarks, 5130 strange antiquarks, 1389 muons, 1081 electrons, 5240 down quarks, 5104 down antiquarks, 6529 antineutrinos, 3862 up quarks, and 3862 up antiquarks.
Simulation ended after 3599.29999999782 yoctoseconds.
— Yodle
स्रोत
एक त्वरित नज़र से, वहाँ एक बेकार व्हाट्सएप है else {U(new T(0>1))और कई पर n < 2 / 3.0, और एक पर n <2/3.0।
— यति
@TuukkaX धन्यवाद, उन याद किया। एक और बाइट को बचाने के लिए 3.0 को 3 डी के साथ बदलकर, पहले वाले को बदलने के बाद उस लाइन को जोड़ना होगा।
— योडल
एक पर if (a.Length, और दूसरे पर if (N[x]!=1, तीसरे पर एक o+= $। इसके अलावा, आप a[0]दो बार पूर्णांक पर पार्स कर रहे हैं , जब परिणाम एक पूर्णांक में सहेजा जा सकता है। मुझे लगता है कि यह Y==1.0हो सकता है Y==1., लेकिन मैं इसके बारे में निश्चित नहीं हूं। i!=0हो सकता है i। मैं कि क्या आपके चर वास्तव में नकारना कर सकते हैं पता नहीं है, लेकिन अगर नहीं, तो आप बदल सकते हैं ==0के साथ <1। शीर्षक सी # 6 कहना चाहिए, क्योंकि आप स्ट्रिंग प्रक्षेप का उपयोग कर रहे हैं।
— यति
@TuukkaX दुर्भाग्य से, C # अगर (पूर्णांक) अनुमति नहीं देता है, जब तक कि मैं कुछ गलत नहीं कर रहा हूं। और मैंने अपनी मुख्य विधि को एक अलग तरीके से छोटा कर दिया, लेकिन मुझे नहीं लगता कि किसी पूर्णांक के लिए [0] को पहले से आवंटित करना संभव है, अगर कोई तर्क नहीं है (डिफ़ॉल्ट एच = 1 और बीज = 1 के साथ चलना है) । हालांकि बाकी सब के लिए धन्यवाद!
— योडल
5

गणितज्ञ, 950bytes-10% = 855 बाइट्स

संपीड़ित का उपयोग कर अभिव्यक्ति:

ToExpression[Uncompress["1:eJxdVG1v2jAQ7of9kMyVpna9pkkKLV0aROlW2AQVb1MqPGsKYCBaYtPEjFLgf+zn7vKGaD/kse/J+fz4zuePI9nr//twdOQ5ZTt0DHvkDLxRwGkTPGZHTs8TExnez6U/5nYvN3vcC+zAaXExU3P7l2Faz7T7m31xiEZuqwPZV5EvZrRLqcUYu62mdH/lq/E8IU3GoAmk6c9msVaXsRQEXoHUpVIy1LpLL/pDYLgn7oTynzPSBeIWKxpAGsEymQ1aQAbeUmvxhUrs3EzWBTk1BXI/96J99IfCPgiOOw6L4AsgnbnEpTGBNpB2us8aSOIepsYLbiIXRbynzDqI1sEIMvZVlDgLII98mWRFEhhnYcSe4EC+BXycua6AYPo8MePvDl6w+Y6o6qtciUMnmVO5xx2Qn28k1VMi+8uSqrlzTBBt83DEoy4dQXPrbofbl+0Tg/DsDK/CQ+ApxQU9yYt3jHX7PqU9ym4N3YSIbvSrUgV0s2SCXqlYoBvXRgnx0rpGNMs3iIZlXSaDaZrJYFilUjaaV7vz6mbzCsMdbFxwERvQQMSCtnCYwgPiMP29gEU67yC2YY34Ak+7HV4khsnZayonmjYdEOiwTrGFiG4uw/q+dTN0y7gCA8WW3qFZtt6jWckwVSxgjJH5gZhcsYQ24gpWiNmx6nCXnwRFDBmcYHZPD3Jo3WSSXZBpElYpvqI3g99wnJbp9NNFbcTs2Hm+qJ08yij0gtq9XAoV0xG70HvLgJ9XW36sTu0O3ihFyWDOtaXw//Io5tpYCuX5eJOxB9PG/CF9QYvSDvBWxQsZc7rJGh+1BbXYcXwoZiYQAkTD1icsIf2CAoIqNz6YgH54PvzSdtcJs1PluZw+9gxu50uhcTHhE82bKh69eSswFZ/D9KlYy7FCOah6EmOg/5kZdRM="]]

असम्बद्ध कोड (1168 बाइट्स -10% = 1051.2bytes):

a=5;m=0;b=Table[H,a];r=RandomChoice;R=RandomReal;l=Length;
q[Q_]:=" "<>ToString[Q[[2]]]<>" "<>Switch[Q[[1]],H,"Higgs Boson",z,"Bottom Quark",Z,"Bottom Antiquark",W,"W Boson",G,"Gluon",TL,"Tau Lepton",L,"Tau Antilepton",f,"Charm Quark",F,"Charm Antiquark",Z,"Z Boson",p,"Photons",M,"Muon",y,"Antimuon",x,"Top Quark",X,"Top Antiquark",P,"Positron",n,"Neutrino",c,"Antineutrino",e,"Electron",w,"Strange Antiquark",W,"Strange Quark",M,"Down Antiquark",o,"Down Quark",A,"Up Antiquark",B,"Up Quark"]
While[MemberQ[b,H|W|Z|x|X],m++;b=Flatten[(Switch[#,H,If[R[]<0.1,r[{.648,.141,.882,.0704,.0327,.0159,.00223,.00111,.000244,.000216}->{{z,Z},{W,W},{G,G},{TL,L},{f,F},{Z,Z},{p,p},{Z,P},{M,y},{x,X}}],H],W,If[R[]<0.5,r[{{P,n},{y,n},{L,n}}],W],Z,If[R[]<0.5,r[{0.206,0.034,0.034,0.034,0.152,0.152,0.152,0.118,0.118}->{{n,c},{e,P},{M,y},{TL,L},{o,M},{w,w},{z,Z},{B,A},{f,F}}],Z],(x|X),If[R[]<0.1295,r[{{W,o},{W,w},{W,z}}]],_,#]
)&/@b];s=q/@(Normal@Counts[b]/.Rule->List);Print["The universe contains"<>StringJoin[Flatten[Transpose[{Table[If[l@s==i,If[l@s==1,""," and"],If[i==1,"",","]],{i,1,l@s}],s}]]]<>"."];]
Print["Simulation ended after "<>ToString[0.1*m]<>" yoctoseconds."]

स्टार्टपमीटर एक के लिए मान बदलकर चुना जा सकता है।

मैंने देखा कि मैंने हिग्स बोसोन के लिए गलत संभावना का उपयोग किया है, लेकिन वर्तमान में इसे बदल सकते हैं (कुछ घंटों में या तो)। तो वर्तमान समाधान में 3 ओडर 4 बाइट्स जोड़ें। (यह एक परीक्षण-मूल्य था)

— जूलियन क्लूज
स्रोत
3
लगभग एक वर्ष के लिए पिछले सबसे अच्छा खड़ा था, और आपने मेरा सिर्फ 10 घंटे बाद पोस्ट किया! वह ठंडा है, यार। :)
— एलेक्स हावान्स्की 24'16
2
चूंकि आपने चुनौती को टक्कर दी थी, इसलिए मुझे यह करना पड़ा। मुझे माफ कर दो। : डी
— जुलिएन क्लूज
5

पर्ल, 973 986 959 944 बाइट्स -10% = 849.6 अंक

इंडेंटेशन और न्यूलाइन्स कोड का हिस्सा नहीं हैं, और पूरी तरह से प्रदान किए जाते हैं ताकि आप इसे पढ़ने के लिए 30 वर्षों तक स्क्रॉल न करें।

0-बाइट अनुकूलन के कुछ जोड़े हैं जिन्हें मैंने कभी भी पूर्ववत नहीं किया था।

%p=(H,Higgs.($o=$".Boson),W,W.$o,Z,Z.$o,B,Bottom.($Q=$".Quark),b,Bottom.($q=$".Antiquark),G,Gluon,A,Tau.($t=$".Lepton),a,Antitau.$t,P,Photon,M,Muon,w,Antimuon,T,Top.$Q,t,Top.$q,e,Positron,N,Neutrino,n,Antineutrino,E,Electron,D,Down.$Q,d,Down.$q,S,Strange.$Q,z,Strange.$q,U,Up.$Q,u,Up.$q,C,Charm.$Q,c,Charm.$q);
%d=(H,[433e-6,.648,Bb,.141,WW,.0882,GG,.0704,Aa,.0327,Cc,.0159,ZZ,.00223,PP,.00111,ZP,244e-6,Mw,216e-6,Tt],W,[.5,$x=1/3,eN,$x,wN,$x,tN],Z,[.5,.206,Nn,.034,Ee,.034,Mw,.034,Aa,.152,Dd,.152,Sz,.152,Bb,.152,Uu,.118,Uu,.118,Cc],T,[.1295,$x,WD,$x,WS,$x,WB],t,[.1295,$x,Wd,$x,Wz,$x,Wb]);
for(@a=(H)x<>;grep/[HWZTt]/,@a;$z++){
    for$m(@a){
        @b=(@b,$m),next if$d{$m}[0]<rand;
        $e=rand;
        ($e-=$d{$m}[($_*=2)+1])>0||($e=2,@b=(@b,split//,$d{$m}[$_+2]))for 0..9
    }
    (@a,@b,%u,$w)=@b;
    $u{$_}++for@a;
    $w.=" $u{$_} $p{$_}".($u{$_}>1?'s,':',')for keys%u;
    say"The universe contains",$w=~s/.$/./r=~s/,([^,]+)$/ and$1/r
}
$z/=10;say"Simulation ended after $z yoctoseconds."

जाहिर है, कोड के थोक प्रारंभिक हैश बना रहा है। %pइसमें सभी कणों के नाम शामिल हैं, जो पर्ल के नंगेपन की सुविधा का फायदा उठा रहे हैं। %rक्षय दर निर्धारित करता है। यदि यह यहाँ चित्रित नहीं है, तो यह बिल्कुल भी क्षय नहीं करता है। %dइसमें क्षय कण होते हैं।

चूंकि आउटपुट में कणों का क्रम मायने नहीं रखता है, इसलिए मैं इसे यादृच्छिक तरीके से बदलने की जहमत नहीं उठाता हूं क्योंकि पर्ल हैश में कुंजियों को एक्सेस करता है, जिससे निम्नलिखित चीजें होती हैं:

[snip]
The universe contains 1 Higgs Boson.
The universe contains 1 Higgs Boson.
The universe contains 2 W Bosons.
The universe contains 2 Neutrinos, 1 Positron and 1 Top Antiquark.
The universe contains 1 Top Antiquark, 1 Positron and 2 Neutrinos.
The universe contains 1 Top Antiquark, 1 Positron and 2 Neutrinos.
The universe contains 1 Top Antiquark, 1 Positron and 2 Neutrinos.
The universe contains 2 Neutrinos, 1 Positron and 1 Top Antiquark.
The universe contains 1 Positron, 1 Top Antiquark and 2 Neutrinos.
The universe contains 2 Neutrinos, 1 Top Antiquark and 1 Positron.
The universe contains 1 Positron, 1 Strange Antiquark, 2 Neutrinos, 1 Bottom Antiquark and 2 W Bosons.
The universe contains 1 W Boson, 1 Bottom Antiquark, 2 Neutrinos, 1 Positron and 1 Strange Antiquark.
The universe contains 2 Neutrinos, 1 Bottom Antiquark, 1 W Boson, 1 Strange Antiquark and 1 Positron.
The universe contains 1 W Boson, 1 Bottom Antiquark, 2 Neutrinos, 1 Strange Antiquark and 1 Positron.
The universe contains 1 Bottom Antiquark, 4 Neutrinos, 1 Antimuon, 2 Positrons and 1 Strange Antiquark.

यह वास्तव में एक प्राणपोषक साहसिक कार्य रहा है। अद्भुत पहेली, ईमानदारी से, मुझे बहुत मज़ा आया! :)

— गेब्रियल बेनामी
स्रोत
5

पायथन 3.6.1, 1183 1157 ... 905 889 * 0.9 = 800.1 बाइट्स

पहली बार इनमें से एक को जमा करने पर यह चुनौती काफी मजेदार लग रही थी इसलिए यहाँ हम चलते हैं ...

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

from random import*
w,z='WZ';b,q,v=' boson',' .quark',[1]*3;p,n,u,t={'H':[433e-6,['Bb',w*2,'GG','Xx','Cc',z*2,'PP','ZP','Mm','Tt'],[6480,1410,882,704,32.7,15.9,2.23,1.11,.244,.216]],w:[.5,['FN','mN','xN'],v],z:[.5,['Nn','EF','Mm','Xx','Dd','Ss','Bb','Uu','Cc'],[2060]+[340]*3+[152]*3+[118]*2],'T':[.1295,['WD','WS','WB'],v]},{'H':'Higgs'+b,'B':'bottom'+q,w:w+b,'G':'gluon','X':'.tau lepton','C':'charm'+q,z:z+b,'P':'photon','M':'.muon','T':'top'+q,'E':'electron','F':'positron','N':'.neutrino','D':'down'+q,'S':'strange'+q,'U':'up'+q},['H']*int(input()),0
while{*u}&{*p}:
    for x in[*u]:
        if x in p and random()<p[x][0]:u.remove(x);u+=choices(*p[x][1:])[0]
    print("The universe contains %s."%' and'.join((', '.join(str(u.count(x))+' '+n[x.upper()].replace('.',(x>x.upper())*'anti')+(1<u.count(x))*'s'for x in{*u})).rsplit(',',1)));t+=.1
print('Simulation ended after %.1f yoctoseconds.'%t)

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

संपादित करें: संक्षिप्तता के हित में, मेरे द्वारा किए गए संपादन की संक्षिप्त सूची (मदद के लिए टिप्पणीकारों का धन्यवाद!):

  • बिल्ली विज़ार्ड के लिए 25 बाइट्स सहेजे गए (न्यूलाइन्स के बजाय अर्धविराम) और दूसरा पायथन जवाब (तार को परिभाषित करने वाले बाइट्स के एक जोड़े को बचाया)।
  • एक और 107 (!) बाइट्स को बचाने के लिए कुछ और चीजों का पता लगाया, ज्यादातर सिर्फ डिक्सेस की बेहतर व्यवस्था की और अब यह एक फ़ंक्शन नहीं है।
  • साकार random.choices()को भारित संभावनाएं हैं, प्रतिशत नहीं, इसलिए मैं कुछ बाइट्स को दस - 28 बाइट्स की कुछ शक्तियों को स्थानांतरित करने से बचा सकता था! हिग्स क्षय की संभावना गलत थी - मैंने 0.043% के बजाय 0.43% पढ़ा ताकि लागत दो बाइट्स हो।
  • एक और 28 बाइट्स को मिश्रित फैंसी ट्रिक्स से बचाया - एक अलग बयान के बजाय any(), चौराहे को सेट करें ।+=list.extend()import
  • सूचियों की एक श्रंखला के लिए नेस्टेड डिक्ट्स की अदला-बदली, choices(*p[x][1:])एक जोड़े को बचाने और x and y or zबचने के लिए इस्तेमाल किया if...else...or।
  • थोड़ा बेहतर असाइनमेंट, LBYL बेहतर तरीके से काम करता है और enumerate()ब्रह्मांड की नकल करके और list.remove()मूल पर उपयोग करके प्रतिस्थापित किया जाता है ( enumerateविधि वैसे भी टूट गई थी जैसा कि होता है)।
  • कुछ ऐसी मूर्खतापूर्ण बातें तय की जो छूट गईं, बेहतर print()बयान और विलय वाले ifबयान। कुछ अनावश्यक कोष्ठक निकाले।

अधिक पठनीय संस्करण:

from random import *
w,z='WZ'
b,q,v=' boson',' .quark',[1]*3
        # Decayable particle products/probabilities
p,n,u,t={'H':[433e-6,['Bb',w*2,'GG','Xx','Cc',z*2,'PP','ZP','Mm','Tt'],[6480,1410,882,704,32.7,15.9,2.23,1.11,.244,.216]],
            w:[.5,['FN','mN','xN'],v],z:[.5,['Nn','EF','Mm','Xx','Dd','Ss','Bb','Uu','Cc'],[2060]+[340]*3+[152]*3+[118]*2],
            'T':[.1295,['WD','WS','WB'],v]},
        # Particle names
        {'H':'Higgs'+b,'B':'bottom'+q,w:w+b,'G':'gluon','X':'.tau lepton','C':'charm'+q,z:z+b,
            'P':'photon','M':'.muon','T':'top'+q,'E':'electron','F':'positron','N':'.neutrino',
            'D':'down'+q,'S':'strange'+q,'U':'up'+q},
        # Universe
        ['H']*int(input()),
        # Time taken
        0
while {*u} & {*p}: # While any particles can still decay
    for x in[*u]: # Iterate through them
        if x in p and random()<p[x][0]: # Check if they should decay
            u.remove(x) # If they should, remove them
            u+=choices(*p[x][1:])[0] # And add in the products
    # Join particle names with their counts together, separated by ',', add 'anti' where
    # needed, add 's' where needed, replace last ',' with 'and', then print.
    a = ' and'.join((', '.join(str(u.count(x))
                    + ' '
                    + n[x.upper()].replace('.',(x>x.upper())*'anti')
                    + (1<u.count(x))*'s' for x in {*u})).rsplit(',',1))
    print("The universe contains %s." % a)
    t+=.1
print('Simulation ended after %.1f yoctoseconds.'%t)

5000 हिग्स बोसोन के साथ नमूना उत्पादन - बाद में देखने के लिए एक बड़ा रन कर सकता है कि क्या कोई शीर्ष क्वार्क क्षय इसे बनाता है:

The universe contains 1 up antiquark, 23 charm quarks, 1 electron, 23 charm antiquarks, 371 tau leptons, 1542 neutrinos, 500 antimuons, 16 antineutrinos, 505 positrons, 4 muons, 3 photons, 3373 bottom quarks, 3373 bottom antiquarks, 1 up quark, 916 gluons and 897 antitau leptons.
Simulation ended after 2410.5 yoctoseconds.

अगर मैंने कुछ भी गलत किया है तो कृपया मुझे बताएं और मैं इसे ठीक करने की कोशिश करूंगा!

— ACraftyMarmoset
स्रोत
4

रूबी, 997 995 बाइट्स -10% = 895.5 अंक

संपादित करें: जोड़ा 'और' अंतिम सीमांकक के रूप में ब्रेडबॉक्स द्वारा देखा

पहली बार पीपीसीजी पर पोस्ट करना, यह एक पुरानी चुनौती है लेकिन मुझे इसे करने में बहुत मजा आया। यहाँ कोड है

s=%w(boson quark top bottom anti tau lepton charm muon neutrino down strange up)
t="Higgs 0;Z 0;W 0;2 1;2 41;3 1;3 41;gluon;5 6;45 6;7 1;7 41;photon;8;48;positron;9;49;electron;#a 1;#a 41;#b 1;#b 41;#c 1;#c 41"
h=[4.33e-2,50,50,12.95]
d=[[64.8,14.1,8.82,7.04,3.27,1.59,0.223,0.111,0.0244,0.0216],[20.6,*[3.4]*3,*[15.2]*3,*[11.8]*2],*[[33.3]*3]*3]
r=["fgcchhijklbbmmbmnode","qrspnoijtuvwfgxykl","pqoqjq","ctcvcf","ctcvcf"]
r=r.map{|a|a.chars.map{|e|e.ord-97}}
s.size.times{|i|c=i>9?"#"+(i+87).chr: i.to_s;t=t.gsub(c,s[i])}
t=t.split(';')
z=Random.new
p=[0]*25
p[0]=gets.to_i
o=0
f=->p{puts"The universe contains "+(*a,b=(0..24).map{|i|e=p[i];e>0?"#{e} "+t[i]+(e>1?"s":""):nil}.compact;a*", "+(a.size>0?" and ":"")+b)+"."}
while p[0..4].sum>0 do
    f[p]
    q=p.clone
    (0..4).map{|i|p[i].times{|j|a=z.rand(100.0);a<h[i]?(q[i]-=1;a=z.rand(100.0);d[i].size.times{|k|a<d[i][k]?(q[r[i][k]]+=1;q[r[i][k+1]]+=1):a-=d[i][k]}):0}}
    p=q.clone
    o+=1
end
f[p]
puts "Simulation ended after #{o/10.0} yoctoseconds."

स्ट्रिंग्स को आवर्ती शब्दों (vars ) द्वारा संपीड़ित किया जाता है sऔर tक्षय के उत्पाद स्ट्रिंग (var r) के रूप में कॉम्पैक्ट रूप से स्टोर होते हैं , प्रत्येक अक्षर एक कण होता है। एक फंक्शन fतार के कण कण की मैपिंग करके ब्रह्मांड की स्थिति को प्रिंट करता है। मुझे लगता है कि राज्य अपडेट लाइन में कटौती करने के लिए कुछ बाइट्स हैं, लेकिन मुझे कुछ भी बेहतर नहीं मिल रहा है।

नमूना आउटपुट

[snip]
The universe contains 1 Higgs boson.
The universe contains 1 Higgs boson.
The universe contains 3 W bosons, 4 gluons and 1 tau lepton.
The universe contains 3 W bosons, 4 gluons and 1 tau lepton.
The universe contains 2 W bosons, 4 gluons, 1 tau lepton, 1 antimuon and 1 neutrino.
The universe contains 2 W bosons, 4 gluons, 1 tau lepton, 1 antimuon and 1 neutrino.
The universe contains 1 W boson, 4 gluons, 1 tau lepton, 3 antimuons, 1 positron and 4 neutrinos.
The universe contains 4 gluons, 1 tau lepton, 4 antimuons, 1 positron and 5 neutrinos.
Simulation ended after 653.2 yoctoseconds.

प्रदर्शन

ये इतना भी बुरा नहीं! इसने 25sec में 100000 हिग्स बोसोन की गणना की

The universe contains 64751 bottom quarks, 93044 bottom antiquarks, 170984 gluons, 59927 tau leptons, 33038 antitau leptons, 14718 charm quarks, 12419 charm antiquarks, 5250 muons, 261567 antimuons, 53148 positrons, 305169 neutrinos, 2142 antineutrinos, 1575 electrons, 14080 down quarks and 7926 down antiquarks.
Simulation ended after 3131.4 yoctoseconds.
— crashoz
स्रोत
साइट पर आपका स्वागत है! क्या आपको >अपने आसपास के रिक्त स्थान की आवश्यकता है while? जब से मैंने रूबी में कुछ भी किया है, तब तक कुछ समय हो चुका है।
— श्रीकोटिलिज्म ओ'जैसिक
एक मुद्दा: आपकी कण सूची में, चुनौती की आवश्यकताओं को पूरा करने के लिए अंतिम अल्पविराम को `और` के साथ प्रतिस्थापित करने की आवश्यकता है।
— ब्रेडबॉक्स
2

डी, 1172 1101 बाइट्स - 10% = 990.9 बाइट्स

import std.random,std.conv,std.stdio,std.algorithm,std.range;alias I=int,V=void,S=string,F=float,U=uniform01!F,W=writef,J=join,X=split;V main(S[]v){I[26]c;c[0]=to!I(v[1]);S[84]s;s[65..$]="antiX bosonXcharm Xdown XelectronXZXgluonXHiggsXtop Xbottom Xup Xtau leptonXmuonXneutrinoXWXphotonXquarkXpositronXstrange ".X('X');S[]f="HBXOBXFBXKQXKAQXDQXDAQXIQXIAQXJQXJAQXSQXSAQXCQXCAQXLXALXEXRXGXPXMXAMXNXAN".X('X');V 
D(I i,F p,F[]d,S v){d~=200;if(c[i]&&U()<p){c[i]--;p=U();foreach(j,q; d){if(p<q/100){c[v[2*j]-65]++;c[v[2*j+1]-65]++;break;}}}}S
C(T)(T s){return(s.length>1)?s[0..$-1].J(", ")~" and "~s[$-1]:s.J(" and ");}I
y=0;while(1){W("The universe contains "~C(iota(0,c.length).filter!(i=>c[i]).map!(i=>to!S(c[i])~" "~f[i].map!(a=>s[a]).J~((c[i]>1)?"s":"")).array)~".\n");y++;if(c[0]+c[1]+c[7]+c[8]<1)break;F[]u=[100/3.0,200/3.0];D(0,.000433,[.0216,.0460,.157,.38,1.97,5.24,12.28,21.1,35.2],"HIVWCUUUCCNOPQTTBBJK");D(2,.5,[11.8,23.6,38.8,54.,69.2,72.6,76.,79.4],"XYRSVWPQFGLMJKDENO");D(1,.5,u,"SXWXQX");D(7,.1295,u,"BFBLBJ");D(8,.1295,u,"BGBMBK");}W("Simulation ended after %f yoctoseconds.\n",y/10.0);}

Ungolfed

import std.random,std.conv,std.stdio,std.algorithm,std.range;
alias I=int,V=void,S=string,F=float,U=uniform01!F;

//uppercase is antiparticle.  The enums are replaced with constants
//in the golfed version.
enum P{ 
    h, w, z, //bosons
    u,U, d,D, t,T, b,B, s,S, c,C,//quarks
    l,L, //tau lepton, antitau lepton
    e,E, //electron,positron
    g, //gluon
    p, //photon
    m,M, //muon, antimuon
    n, N, //neutrino, antineutrino
};

void main(string[] v) {
    int[26]c;//particle counts
    c[0]=to!int(v[1]);//mandatory argument

    string format_particle(ulong i) {
        string[84] strs;
        strs[65..$]=["anti"," boson","charm ","down ","electron",/*f*/"Z",
        "gluon","Higgs",/*i*/"top ",/*j*/"bottom ",/*k*/"up ","tau lepton","muon","neutrino",/*o*/"W","photon","quark",/*r*/"positron","strange "];
        string[] fmt = [
            "HB","OB","FB",//bosons
            "KQ","KAQ",//up
            "DQ","DAQ",//down
            "IQ","IAQ",//top
            "JQ","JAQ",//bottom
            "SQ","SAQ",//strange
            "CQ","CAQ",//charm
            "L","AL",//Tau leptons
            "E","R",//electron/positron
            "G", //gluon
            "P", //photon
            "M","AM", //muon, antimuon
            "N", "AN", //neutrino, antineutrino
        ];
        //In the golfed version, we instead use X to delimit strings and call split to convert to array.

        return to!string(c[i])
            ~ " " ~ fmt[i].map!(a=>strs[a]).join
            ~ ((c[i]>1) ? "s" : "");
    }

    /* if there exist any of particle `i`, 
       it decays with probability `p`.
       into the particles specified in `v[j]`
       where `j` is drawn from distribution `decay_probs` */
    void decay(int i, float p, float[] decay_probs, P[] v...) {
        decay_probs ~= 2;//1.0, but with a margin for error in case of floating point precision issues
        if (c[i] && U()<p){
            c[i]--;

            p=U();
            foreach(j,q; decay_probs) {
                if (p<q) {
                    c[v[2*j]]++;
                    c[v[2*j+1]]++;
                    /*writef("Decay %s, Add: %s, %s\n",
                        format_particle(i),
                        format_particle(v[2*j]), format_particle(v[2*j+1]));*/
                    break;
                }
            }
        }
    }

    int y=0;
    while(1) {
        string commas(T)(T s) {
            return (s.length > 1)
                ?  s[0..$-1].join(", ") ~ " and " ~ s[$-1]
                :  s.join(" and ");
        }

        //print line for particle `d`
        writef("The universe contains " 
            ~ commas(
                iota(0,c.length)
                    .filter!(i=>c[i])
                    .map!(i=>format_particle(i))
                    .array) ~ ".\n");

        y++;
        if(c[P.h]+c[P.w]+c[P.t]+c[P.T]<1)break;

        F[] u = [1/3.0,2/3.0];
        decay(P.h, .000433,
            [.000216,.000460,.00157,.0038,.0197,.0524,.1228,.211,.352],
            P.t,P.T, P.m,P.M, P.z,P.p, P.p,P.p, P.z,P.z, P.c,P.C, P.l,P.L, P.g,P.g, P.w,P.w, P.b,P.B); 
        decay(P.z, .5,
            [.118,.236,.388,.54,.692,.726,.76,.794],
            P.n,P.N, P.e,P.E, P.m,P.M, P.l,P.L, P.d,P.D, P.s,P.S, P.b,P.B, P.u,P.U, P.c,P.C);
        decay(P.w,    .5, u, P.E,P.n, P.M,P.n, P.L,P.n);
        decay(P.t, .1295, u, P.w,P.d, P.w,P.s, P.w,P.b);
        decay(P.T, .1295, u, P.w,P.D, P.w,P.S, P.w,P.B);
        //In the golfed version, the list of enums is replaced by a string: each char is 65 + the enum's value.  D() is adjusted to subtract it again.
    }

    writef("Simulation ended after %f yoctoseconds.\n", y/10.0);
}
— रे
स्रोत
2

कोटलिन : 1330 - 10% = 1197 बाइट्स

मेरा पहला कोड गोल्फ सबमिशन है; सूचियों को नक्शे की तुलना में गोल्फर होने के कारण बहुत अक्षम, लेकिन प्रतीत होता है कि सही है! जेवीएम या जेएस कार्यान्वयन पर काम करता है, और एक वैकल्पिक (वैकल्पिक) तर्क लेता है।

operator fun String.minus(p:Pair<String,String>)=replace(p.first,p.second)
operator fun<A,B>A.div(b:B)=to(b)
val l=1.0
val e=l/3
val t=l-e
enum class V(val c:Double=.0,vararg val v:Pair<Pair<V,V>,Double>){E,F,G,P,L,AL,M,AM,N,AN,_Q,_AQ,CQ,CAQ,DQ,DAQ,SQ,SAQ,UQ,UAQ,WB(.5,P/N/e,AM/N/t,AL/N/l),TQ(.1295,WB/DQ/e,WB/SQ/t,WB/_Q/l),TAQ(.1295,WB/DAQ/e,WB/SAQ/t,WB/_AQ/l),ZB(.5,N/AN/.206,E/P/.24,M/AM/.274,L/AL/.308,DQ/DAQ/.46,SQ/SAQ/.612,_Q/_AQ/.764,UQ/UAQ/.882,CQ/CAQ/l),HiggsB(.000433,_Q/_AQ/.648,WB/WB/.789,G/G/.8772,L/AL/.9476,CQ/CAQ/.9803,ZB/ZB/.9962,F/F/.99843,ZB/F/.99954,M/AM/.999784,TQ/TAQ/l);fun d()=if(Math.random()<c)with(Math.random()){v.first{this<it.second}.first.toList()}else listOf(this)
override fun toString()=name-"_"/"bottom "-"A"/"anti"-"B"/" boson"-"C"/"charm "-"D"/"down "-"E"/"electron"-"F"/"photon"-"G"/"gluon"-"L"/"tau lepton"-"N"/"neutrino"-"M"/"muon"-"P"/"positron"-"Q"/"quark"-"S"/"strange "-"T"/"top "-"U"/"up "}
fun main(vararg a:String){var t=.0
var l=List(a.lastOrNull()?.toInt()?:1){V.HiggsB}
while(true){++t
var s="The universe contains"
with(l.toSet()){forEachIndexed{i,p->l.count{it==p}.let{s+=(" $it $p")
if(it>1)s+='s'
s+=when(size){i+1->"."
i+2->" and"
else->","}}}}
println(s)
if(l.filter{it.c>0}.isEmpty())break
for(p in l){l-=p;l+=p.d()}}
t/=10
print("Simulation ended after $t yoctoseconds.")}

कम गोल्फ वाला संस्करण

operator fun String.minus(p:Pair<String,String>)=replace(p.first,p.second)
operator fun<A,B>A.div(b:B)=to(b)
val l=1.0
val e=l/3
val t=l-e
enum class V(val c:Double=.0,vararg val v:Pair<Pair<V,V>,Double>){
    E,F,G,P,L,AL,M,AM,N,AN,_Q,_AQ,CQ,CAQ,DQ,DAQ,SQ,SAQ,UQ,UAQ,
    WB(.5,P/N/e,AM/N/t,AL/N/l),
    TQ(.1295,WB/DQ/e,WB/SQ/t,WB/_Q/l),
    TAQ(.1295,WB/DAQ/e,WB/SAQ/t,WB/_AQ/l),
    ZB(.5,N/AN/.206,E/P/.24,M/AM/.274,L/AL/.308,DQ/DAQ/.46,SQ/SAQ/.612,_Q/_AQ/.764,UQ/UAQ/.882,CQ/CAQ/l),
    HiggsB(.000433,_Q/_AQ/.648,WB/WB/.789,G/G/.8772,L/AL/.9476,CQ/CAQ/.9803,ZB/ZB/.9962,F/F/.99843,ZB/F/.99954,M/AM/.999784,TQ/TAQ/l);
    override fun toString()=name-
        "_"/"bottom "-
        "A"/"anti"-
        "B"/" boson"-
        "C"/"charm "-
        "D"/"down "-
        "E"/"electron"-
        "F"/"photon"-
        "G"/"gluon"-
        "L"/"tau lepton"-
        "N"/"neutrino"-
        "M"/"muon"-
        "P"/"positron"-
        "Q"/"quark"-
        "S"/"strange "-
        "T"/"top "-
        "U"/"up "
    fun d()=if(Math.random()<c)
        with(Math.random()){
            v.first{this<it.second}.first.toList()
        }else listOf(this)
}
fun main(vararg a:String){
    var t=.0
    var l=List(a.lastOrNull()?.toInt()?:99){V.HiggsB}
    while(true){
        ++t
        var s="The universe contains"
        with(l.toSet()){
            forEachIndexed{i,p->
                l.count{it==p}.let{
                    s+=(" $it $p")
                    if(it>1)s+='s'
                    s+=when(size){
                        i+1->"."
                        i+2->" and"
                        else->","
                    }
                }
            }
        }
        println(s)
        if(l.filter{it.c>0}.isEmpty())break
        for(p in l){l-=p;l+=p.d()}
    }
    t/=10
    print("Simulation ended after $t yoctoseconds.")
}
— रयान हिल्बर्ट
स्रोत
1

काफी समय से जमा है।

इतना गोल्फ नहीं है लेकिन फिर भी दूसरे अजगर से कम है।

इनपुट के रूप में हिग्स की प्रारंभिक मात्रा लें।

पायथन 3 , 1134 1120 बाइट्स - 10% = 1020.6 1008 अंक

from random import *
n=int(input())
M=random
seed()
def D(i):
 for a in i:d[a]=d[a]+1 if a in d else 1
def X(p,A,B):
 for l in d[s]*' ':
  n[0]=1
  if M()<=p:d[s]-=1;r=M();D(A[B.index(next(x for x in B if x>r))])
s=lambda x:x.replace(Z,'')
Z,C,e,i,k,m,p,t,v='anti, boson,electron,gluon,neutrino,muon,photon,tau lepton,positron'.split(',')
B=' '+Z+'quark'
a='bottom'+B
c='charm'+B
f='down'+B
h="Higgs"+C
o='top'+B
u=Z+k
w="W"+C
x=Z+m
y=Z+t
z='Z'+C
S='strange'+B
U='up'+B
b,g,j,q,Q,T=map(s,[a,f,c,o,S,u])
d={h:n,0:0}
I=0
A=[(a,b),(w,w),(i,i),(t,y),(c,j),(z,z),(p,p),(z,p),(m,x),(o,q)]
B=[.648,.789,.8772,.9476,.9803,.9962,.99843,.99954,.999784,1]
O=[[k,v],[k,x],[k,y]]
E=[1/3,2/3,1]
F=[(u,k),(e,v),A[8],A[3],(g,f),(S,Q),A[0],(T,U),(c,j)]
G=[.206,.24,.274,.308,.46,.612,.764,.882,1]
H=[[w,g],[w,Q],[w,a]]
n={1}
while n:
 I+=1
 n={}
 P=dict(d)
 for s in P:
  if s==h:X(.00433,A,B)
  if s==w:X(.5,O,E)
  if s==z:X(.5,F,G)
  if s in [q,o]:X(.1295,H,E)
 l='The universe contains '
 for s in d:l+= str(d[s])+' '+s+'s'*(d[s]>1)+', ' if d[s]>0 else ''
 print(l[:-2]+'.')
print('Simulation ended after '+str(I/10)+' yoctoseconds.')

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

— frosqh
स्रोत
1

एफ #, 1993 1908 बाइट्स - 10% = 1718 बाइट्स

open System
let r=new Random()
let p()=r.NextDouble()*100.0
type P=
 |A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z
let q="quark"
let n=dict[(A,"Higgs boson");(B,"Bottom "+q);(C,"Bottom anti"+q);(D,"Top "+q);(E,"Top anti"+q);(F,"W boson");(G,"Gluon");(H,"Tau lepton");(I,"Anti-tau lepton");(J,"Charm "+q);(K,"Charm anti"+q);(L,"Z boson");(M,"Photon");(N,"Muon");(O,"Antimuon");(P,"Antiquark");(Q,"Positron");(R,"Neutrino");(S,"Antineutrino");(T,"Electron");(U,"Down"+q);(V,"Down anti"+q);(W,"Strange "+q);(X,"Strange anti"+q);(Y,"Up "+q);(Z,"Up anti"+q);]
let c(u:P seq)=Option.isSome(Seq.tryFind(fun p->Seq.contains p [A;F;L;D])u)
let w()=
 if r.Next(2)=0 then
  let p=r.Next(3)
  if p=0 then[Q;R]elif p=1 then[O;R]else[I;R]
 else[F]
let t a=
 if p()<12.95 then
  let p=r.Next(3)
  if p=0 then[F;U]elif p=1 then[F;W]else[F;B]
 else[a]
let h()=
 if p()<0.0433 then
  let p=p()
  if p<64.8 then[B;C]elif p<78.9 then[F;F]elif p<87.72 then[G;G]elif p<94.76 then[H;I]elif p<98.03 then[J;K]elif p<99.62 then[L;L]elif p<99.843 then[M;M]elif p<99.954 then[L;M]elif p<99.9784 then[N;O]else[D;E]
 else[A]
let z()=
 if r.Next(2)=0 then
  let p=p()
  if p<20.6 then[R;S]elif p<24.0 then[T;Q]elif p<27.4 then[N;O]elif p<30.8 then[H;I]elif p<46.0 then[U;V]elif p<61.2 then[W;X]elif p<76.4 then[B;C]elif p<88.2 then[Y;Z]else[J;K]
 else[F]
let d u=List.map(fun p->if p=A then h()elif p=F then w()elif p=L then z()elif p=D||p=E then t p else[p])u|>List.concat 
let b h=List.init h (fun x->id A)
let o u=
 let e=List.countBy id u|>List.map(fun t->n.[fst t],snd t)|>List.map(fun t->
   if snd t>1 then(snd t,(fst t)+"s")else snd t,fst t)
 String.Join(", ",(List.map(fun x->(string(fst x))+" "+(snd x))e))|>printfn"The universe contains %s."
let [<EntryPoint>]m a=
 let mutable u=int a.[0]|>b
 let mutable t=0
 while c u do
  o u
  u<-d u
  t<-t+1
 o u
 (float t)/10.0|>printfn"Simulation ended after %f yoctoseconds."
 0

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

यह इस तरह दिखता है:

यह बहुत सारे कण है ...

— Ciaran_McCarthy
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.