Одним із приємних властивостей мови, що повністю відповідає Тюрінгу, є те, що вона може використовуватися для написання будь-якої програми, аж до моделювання всього Всесвіту.

Ваше завдання - зробити саме це: написати програму, яка імітує Всесвіт .

Примітка. Хоча я не сумніваюся, що ви зможете виконати це завдання, в наш час у мене не вистачає вільного часу, щоб перевірити, чи всі 10 ⁹⁰ частинок у вашому моделюванні роблять те, що вони насправді повинні робити. Тому виключно для спрощення тестування та оцінювання достатньо, якщо ваш тренажер Всесвіту працює лише з однією стартовою частинкою. Щоб зробити речі цікавими, припустимо, що ця частинка є нещодавно відкритим Хіггсом Бозоном.

Ваш Всесвіт починається ні з чим, крім єдиного Хіггса Босона, приблизно 120 ГеВ в середині нього. Щоб не робити висновок занадто довгим, давайте зробимо цей Всесвіт галочкою лише ^10-25 секунд замість його «звичайної тактової частоти» 5,4 × ^10–44 секунди.

Цей бозон Хіггса рано чи пізно загниє, оскільки має період напіввиведення 1,6 × ^10-22 секунди, тому при кожному галочці моделювання він має 0,0433% шанс загнивання. Ви можете перевірити тут, у що воно занепаде . Щоб мати центральну та спрощену вимогу, я перелічую коефіцієнти розгалуження, які ви повинні використовувати:

Запуск моделювання

При кожному галочці моделювання бозон Хіггса має 0,0433% шансу загнивання. Якщо це станеться, він розпадеться на наступні частинки із переліченими ймовірностями (ви повинні використовувати ці імена у висновку):

• нижній кварк + нижній антикварк (64,8%)
• 2 Вт бозони (14,1%)
• 2 глюони (8,82%)
• тау лептон + антитау лептон (7,04%)
• шарм-шарм + шарм-антикварк (3,27%)
• 2 Z бозони (1,59%)
• 2 фотони (0,223%)
• 1 Z бозон + 1 фотон (0,111%)
• мюон + антимуон (0,0244%)
• верхній кварк + верхній антикварк (0,0216%)

Загалом на 100%.

Деякі з цих частинок занепадають далі.

W бозон : період напіввиведення ^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% шансу розпадатися при кожному галочці на наступні, з однаковими ймовірностями:

• Ш бозон + пух кварк
• Ш бозон + дивний кварк
• Ш бозон + нижній кварк

Звичайно, W бозон також незабаром занепаде ...

Верхні антикваркових поводиться так само , як топ - кварк: він розпадається на W - бозон і оголошення / с / б антікварк.

У всіх інших частинок (тому всі, окрім Z і W бозонів і верхніх кварків) є напіввиведення на багато порядків довше, щоб не захаращувати вихід, всі вони вважаються стабільними для нашого моделювання .

Оскільки Всесвіт багато в чому порожній, всі частинки матимуть достатньо місця для себе і не будуть взаємодіяти між собою. Тому всі окремі частинки незалежні одна від одної в будь-якому відношенні, включаючи ймовірність розщеплення.

Вихід:

Кожен галочок моделювання, ви повинні надрукувати вміст змодельованого Всесвіту в новий рядок. Наприклад:

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 йоктосекунди, але вам буде прощено, якщо для друку результатів буде потрібно більше часу, ніж для вашої програми.

Моделювання закінчується, коли залишаються лише "стабільні" частинки.

Оцінка балів

Діють стандартні правила гольф-коду.

Генератор випадкових чисел може бути псевдовипадковим, але ви повинні викласти його, якщо мова не запускає його за замовчуванням. Розподіл вірогідності вашого RNG повинен бути рівномірним.

• Ви отримаєте бонус -10% до розміру коду, якщо програма візьме ціле число як вхід, і розпочнеться з цих багатьох бозонів Хіггса.

Виняток для любителів машин Тьюрінга.

Для тих, хто наважиться спробувати свою удачу з фактичною машиною Тюрінга або подібною мовою (наприклад, Brainfuck), їх завдання полегшується наступними змінами правил (застосовно лише якщо мова є похідною Brainfuck або іншим чином дуже спрощеною системою Turing- машина, нездатна до призначення, не має ALU та значень на стрічці, може збільшуватися та зменшуватися лише одним) :

• Назви частинок спрощено до d, s, b, t, u, c для кварків, v для нейтрино, T для тау лептону, m для мюона, г для глюона, p для фотона, Z, W і H для бозони, - для електрона і + для позитрона. На кожному галочку вводиться вхід зі значенням 0 або 1 зі стандартного вводу, вказується, чи нестабільна перша частинка у списку занепадає чи ні.

Тому прикладним результатом стане

H
H
H
H
W W
W W
W + n
+ !T n n

Pyth , 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

Рядок - це розділений на підкреслення список частинок, і, якщо частинка нестабільна, її поведінка - це розділений пробілом список, що складається з її періоду напіввиведення в симуляційних кліщах з подальшим розпадом, разом з різними ймовірностями кожної. Кожна частинка має однобуквений код, пов'язаний з нею, що визначається їх положенням у списку, індексованим в нижній регістр алфавіту, - отже, бозон Хіггса є aW бозоном b, аж до буття електрона y.

Замість того, щоб зберігати ймовірності розпаду, замість цього зберігається період напіврозпаду, а ймовірність обчислюється під час обробки словника. Використовувана формула полягає в тому, P=1-(1/2)^(1/h)де Pє ймовірність розпаду на кліща, і hце період напіврозпаду частинки, виміряний у кліщах.

Нестабільні частинки - перші чотири в списку. Оскільки кількість цих частинок є тим, що визначає, коли моделювання закінчується, наявність їх на початку списку дозволяє легко перевірити їх згодом.

Проблема в тому, що цей рядок величезний - 436 байт! - а використання вбудованого струнного стиснення Pyth насправді збільшує кількість байтів, оскільки в ньому використовується стільки багатобайтових символів. Я зупинився на порівняно простій ітераційній схемі стиснення словника. Фрагмент 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

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 додаткових байтів), але він працює набагато швидше для тестування величезних чисел. Оскільки він недостатньо короткий для конкуренції, я також додав трохи коду, щоб відстежувати час виконання в реальному світі та друкувати його відразу після імітованого часу. Моя оригінальна версія зробила n = 100 к за приблизно 8 хвилин. Наведена вище версія робить це приблизно за 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;}

Вибірка зразка (без аргументів)

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.

Вибірка зразка (univers.exe 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.

Вибірка вибірки (univers.exe 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тому воно піде набагато швидше. З Notepad ++, ви можете потім відкрити 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

Пітон 3, 1,247 * 0,9 = 1,122,3

Ну, це мій найдовший запис з дальнього пострілу, але принаймні я коротший за С ++.

Тепер із додатковим бонусом! Його потрібно викликати цифрою як перший аргумент.

Мій Всесвіт не працював з розпадаючими частинками, окрім Хіггса Босона, але зараз це відбувається. Крім того, у мене не було правильної множини чи пунктуації, але я фактично це роблю зараз.

Я наближаюся до Sub 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))

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

Деякі пояснення: Бог і Людина

Існує 2 структури даних, що містять фізику %pта називання %h; Бог і людина як би. Фізичний хеш дає набір рядків, індексованих оригінальною літерою нестійких частинок, яку можна розділити, хешировать і перетворити на Mix:

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 падає до ВВ, з імовірністю зважування 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і підміняємо його у нашому Всесвіті "HtT" -> "HWbT". Кожна нестабільна частинка має себе як можливий рулон, що дозволяє нам спростити структуру, порівняно з необхідністю перевірити, розклалася вона чи ні; більшу частину часу, коли ви переходите на "H", ви знову отримуєте "H".

Експериментальна теорія струн

Ви можете спостерігати, як рядок Всесвіту розвивається за допомогою цієї модифікованої версії .

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

Продуктивність

Я взяв це на 100 H на TIO, неминуче, якщо ви хочете піти набагато далі, краще було б внести деякі зміни, це все-таки велика об'єднана теорія струн.

Groovy, 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}}

PHP, 989 - 10% = 890,1 байт

Sub 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')));

Ось те ж саме з перервами рядків для, uh ... "читабельності" ...

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

QBasic 2161 * .9 = 1945 2028 * .9 = 1825 1854 * .9 = 1669 байт

Тепер, коли QBasic - це ЛОТМ, я думав, що перегляну свою першу відповідь на 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.

C # 6, 3619 3617 3611 3586 - 10% = 3227,4 байт

Програма бере два необов'язкові аргументи для кількості стартових Хіггсових Бозонів та насіння, яке потрібно використовувати для класу Random.

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.

Mathematica, 950 байт-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,2 байт):

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

Стартовий параметр можна вибирати, змінюючи значення для a.

Я помітив, що я використовував неправильну ймовірність для бозона Хіггса, але наразі не можу його змінити (через кілька годин або близько того). Тому додайте 3 поточні 4 байти до поточного розчину. (Це було тестовим значенням)

Perl, 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містить частинки гниття.

Оскільки порядок частинок у висновку не має значення, я не переймаюся його зміною випадковим чином, коли Perl отримує доступ до ключів у хеші, що призводить до таких речей, як:

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

Це справді було хвилюючою пригодою. Чудова головоломка, чесно кажучи, мені було дуже весело! :)

Python 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 байт завдяки Cat Wizard (крапки з комою замість нових рядків) та іншій відповіді Python (збережено пару байтів, що визначають рядки).
• З'ясував ще кілька речей, щоб зберегти ще 107 (!) Байт, здебільшого просто краще розташування диктів, і це вже не функція.
• Реалізована random.choices()зважена ймовірність, а не відсоток, тому я міг би врятувати кілька байт від зміщення речей на кілька потужностей на десять - 28 байт, збережених! Ймовірність розпаду Хіггса була помилковою - я прочитав 0,43% замість 0,043%, так що це коштувало двох байтів.
• Збережено ще 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.

Якщо я зробив щось не так, то, будь ласка, повідомте мене, і я спробую це виправити!

Рубі, 997 995 байт -10% = 895,5 балів

редагувати: додано "і" як останній роздільник, як помічено хлібопечкою

Вперше розміщуючи повідомлення про PPCG, це давнє завдання, але мені це було дуже весело. Ось код

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.

Продуктивність

Це не так вже й погано! Він обчислив 100000 бозонів Хіггса за 25 секунд

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.

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

Безумовно

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

Котлін : 1330 - 10% = 1197 байт

Моє перше в історії подання коду для гольфу; дуже неефективний через те, що списки є гравцями, ніж карти, але, здавалося б, правильно! Працює над реалізацією JVM або JS та бере аргумент (необов'язково).

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.")
}

Досить довге подання.

Не так багато гольфу, але все ж коротше, ніж інший пітон.

Візьміть початкову кількість Хіггса як вхідну.

Python 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.')

Спробуйте в Інтернеті!

F #, 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

Спробуйте в Інтернеті!

Незайманий виглядає так: