태그 보관물: random

random

우주를 시뮬레이션! 있을지 확신 할 수 없지만, 현재 시뮬레이션에

튜링 완성 언어의 좋은 점 중 하나는 전체 우주의 시뮬레이션을 포함하여 모든 프로그램을 작성하는 데 사용할 수 있다는 것입니다.

당신의 임무는 정확히 그렇게하는 것입니다 : 우주를 시뮬레이트하는 프로그램을 작성하십시오 .

참고 :이 작업을 수행 할 수 있을지 확신 할 수 없지만, 현재 시뮬레이션에 포함 된 입자 10 90 개 모두가 실제로 수행해야하는 작업을 수행 하는지 여부를 확인할 수있는 여가 시간이 충분하지 않습니다 . 따라서 테스트 및 평가를 단순화하기 위해 유니버스 시뮬레이터가 단일 시작 입자로만 작동하는 것으로 충분합니다. 흥미로운 점을 유지하기 위해이 입자가 최근에 발견 된 Higgs Boson이라고 가정 해 봅시다.

당신의 우주는 그 중간에 약 120 GeV의 단일 Higgs Boson으로 시작합니다. 출력을 너무 길게 만들지 않으려면 “일반 클럭 속도”5.4 × 10 -44 초 대신 이 유니버스를 10-25 초만 틱으로 설정해 보겠습니다 .

이 Higgs boson은 1.6×10 -22 초의 반감기를 가짐으로써 조만간 부패 할 것이므로 시뮬레이션의 모든 틱마다 0.0433 %의 부패 확률이 있습니다. 여기에서 썩는 부분을 확인할 수 있습니다 . 중앙 집중식 요구 사항을 단순화하기 위해 사용해야 할 분기 비율을 나열합니다.

시뮬레이션 실행

시뮬레이션의 틱마다 Higgs boson은 0.0433 %의 부패 확률을가집니다. 이 경우 나열된 확률로 다음 입자로 붕괴됩니다 (출력에 이러한 이름을 사용해야 함).

  • 바텀 쿼크 + 바텀 안티 쿼크 (64.8 %)
  • 2W 보손 (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 boson : 반감기 10 -25 초로, 같은 확률로 모든 틱에서 50 % 확률로 다음 중 하나에 부패 할 수 있습니다.

  • 양전자 + 중성미자
  • 안티 무온 + 중성미자
  • 안티 타우 렙톤 + 뉴트리노

Z boson : 반감기 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 보손 + 이상한 쿼크
  • W 보손 + 바텀 쿼크

물론, W boson도 곧 부패 할 것입니다 …

톱 쿼크는 상단 쿼크와 유사하게 작동 : 그것은 W 보손 및 광고 / S / B의 쿼크로 붕괴.

다른 모든 입자 (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의 확률 분포는 균일해야합니다.

  • 프로그램이 정수를 입력으로 사용하고 많은 Higgs boson으로 시작하면 코드 크기에 -10 %의 보너스를 얻게됩니다.

튜링 머신 애호가를위한 예외입니다.

실제 Turing 머신 또는 유사한 언어 (Brainfuck와 같은)로 행운을 시험하려는 사람들 은 다음 규칙 변경을 통해 작업을보다 쉽게 ​​수행 할 수 있습니다 (언어가 Brainfuck-derivative이거나 다른 단순화 된 Turing- 할당 할 수없고, ALU가없고, 테이프의 값은 하나만 증감 될 수 있습니다 .

  • 입자 이름은 쿼크의 경우 d, s, b, t, u, c, 중성미자의 경우 v, 타우 렙턴의 경우 T, 뮤온의 경우 m, 글루온의 경우 g, 광자의 경우에는 p, 광자, Z, W 및 H로 단순화됩니다. bosons-전자의 경우와 양전자의 경우 +. 각각의 틱에서, 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 % 보너스를받습니다. 여기 에서 온라인으로 시도하거나 Higgs boson의 반감기를 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

문자열은 밑줄로 구분 된 입자의 목록이며, 입자가 불안정한 경우 동작-시뮬레이션 진드기의 반감기와 그 각각의 고유 한 아기와 함께 붕괴되는 것으로 구성되는 공백으로 구분 된 목록입니다. 각 입자에는 소문자 알파벳으로 색인 된 목록의 위치에 따라 단일 문자 코드가 연결되어 있습니다. 따라서 Higgs boson은 aW boson은 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에있는 입자가 Higgs boson이므로 유니버스의 초기 상태는 입력 숫자 배열과 24 개의 0입니다.

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 추가 바이트) 짧은 아니지만, 실행 방법 큰 숫자를 테스트하기 위해 빠르게. 경쟁하기에는 짧지 않기 때문에 실제 실행 시간을 기록하고 시뮬레이트 된 시간 직후에 인쇄하는 작은 코드도 추가했습니다. 내 원래 버전은 약 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;}

샘플 출력 (인수 없음)

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.

샘플 출력 (universe.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.

샘플 출력 (universe.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갈 것이다, 그래서 훨씬 더 빨리. 메모장 + +로, 당신은 개방 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

글쎄, 이것은 롱 샷으로 가장 긴 항목이지만 적어도 C ++보다 짧습니다.

보너스가 추가되었습니다! 첫 번째 인수로 숫자를 사용하여 호출해야합니다.

내 우주는 iggs 스 보손 (Higgs Boson) 이외의 부패하는 입자로는 작동하지 않았지만 지금은 그렇지 않습니다. 또한 복수형이나 문장 부호가 맞지 않았지만 실제로 는 실제로 합니다.

서브 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))

답변

펄 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맵시 쿼크와 매력 쿼크 대.

그리고 남자는 조금 생각하고 그것을 antitau lepton이라고지었습니다.

이름 지정은 모두에 설정되어 있으며 %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"H 스 보손이 하나 인 우주도 마찬가지 입니다. 생성기 구조 _,_..._는 루프를 만드는 데 사용되며, 유니버스 문자열의 상태 ( $_)를 인쇄하는 것과 분리합니다. 인쇄는 유니버스의 문자를 자루에 넣고 결과 개수를 복수로 매핑하여 수행됩니다.

입자를 재채기

진화하는 입자는 해당 입자에 대한 믹스에서 선택한 값으로 매핑하는 것입니다. 그래서 t, 상단 쿼크가로 진화

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

Perl6을 사용하면 바닥을 통해 간단하게 가중치를 부여받은 키 중 하나를 임의로 선택할 수 있습니다 .roll. 그래서 우리는 그것을 “HtT”-> “HWbT”우주로 굴려서 t말하고 Wb대체합니다. 각각의 불안정한 입자는 가능한 롤로서 그 자체를 가지므로, 구조를 단순화하고 붕괴 여부를 확인해야합니다. 대부분 “H”를 굴리면 “H”가 다시 나타납니다.

실험적인 스트링 이론

이 수정 된 버전을 통해 유니버스 문자열이 진화하는 것을 볼 수 있습니다 .

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

공연

나는 TIO에서 100 H까지 그것을 가져갔습니다. 필연적으로 더 멀리 가고 싶다면 약간의 변경을하는 것이 더 좋을 것입니다. 이것은 결국 Grand Unified String Theory입니다.

답변

그루비, 1506 1454-10 % = 1309 바이트

시작 Higgs boson 입자의 수가 명령 행에서 첫 번째 인수로 제공되었다고 가정하십시오.

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 바이트

서브 1K 베이비! 고마워 vsz, 이것은 정말 재미있는 도전이었습니다. 너무 많은 방법으로 결과를 확인하기가 매우 어렵습니다.

프로그램은 명령 행 인수를 사용하여 iggs 스 보손의 시작 번호를 지정할 수 있습니다. 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.

답변

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.