Одним из замечательных свойств языка, полного Тьюринга, является то, что его можно использовать для написания любой программы, вплоть до симуляции всей Вселенной.
Ваша задача сделать именно это: написать программу, которая имитирует Вселенную .
Примечание: хотя я не сомневаюсь, что вы сможете выполнить эту задачу, в настоящее время у меня нет достаточно свободного времени, чтобы проверить, все ли 10 90 частиц в вашей симуляции делают то, что они действительно должны делать. Следовательно, для упрощения тестирования и оценки достаточно, чтобы симулятор вселенной работал только с одной стартовой частицей. Для интереса, давайте предположим, что эта частица - недавно открытый бозон Хиггса.
Ваша вселенная начинается только с одного бозона Хиггса с энергией приблизительно 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 boson : период полураспада 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 бозон + странный кварк
- W бозон + нижний кварк
Конечно, 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 yoctoseconds, но вы будете прощены, если вашей программе потребуется больше времени, чтобы распечатать вывод.
Симуляция заканчивается, когда остаются только «стабильные» частицы.
счет
Применяются стандартные правила игры в гольф.
Генератор случайных чисел может быть псевдослучайным, но вы должны его заполнить, если по умолчанию язык не заполнен. Распределение вероятностей вашего RNG должно быть равномерным.
- Вы получите бонус -10% к размеру кода, если программа примет целое число в качестве входных данных и начнет с таким количеством бозонов Хиггса.
Исключение для любителей машин Тьюринга.
Для тех, кто осмелится попытать счастья с реальной машиной Тьюринга или подобным языком (например, Brainfuck), их задача облегчается благодаря следующим изменениям правил (применимо, только если язык является производным от Brainfuck или иным образом очень упрощенным языком Тьюринга. машина, неспособная к назначению, не имеющая ALU, и значения на ленте могут только увеличиваться и уменьшаться на единицу) :
- Названия частиц упрощены до d, s, b, t, u, c для кварков, v для нейтрино, T для тау-лептона, m для мюона, g для глюона, p для фотона, Z, W и H для бозоны, - для электрона и + для позитрона. На каждом тике вход со значением 0 или 1 предоставляется из стандартного ввода, указывающего, затухает ли первая нестабильная частица в списке или нет.
Таким образом, выходной пример станет
H
H
H
H
W W
W W
W + n
+ !T n n
SimulateUniverse
встроенная функция?Ответы:
Pyth , 572 * 0,9 = 514,8 байта
Соответствует бонусу -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 байт. Словарь построен с использованием следующей строки:
Строка представляет собой разделенный подчеркиванием список частиц и, если частица нестабильна, ее поведение - разделенный пробелами список, состоящий из периода полураспада в тиках симуляции, за которым следует то, во что она распадается, вместе с различными вероятностями каждой из них. С каждой частицей связан однобуквенный код, заданный ее положением в списке, проиндексированном в строчный алфавит - так что бозон Хиггса
a
, W-бозонb
, вплоть до электрона, являющегосяy
.Вместо того, чтобы хранить вероятности затухания, вместо этого сохраняется период полураспада и вычисляется вероятность при обработке словаря. Используемая формула:
P=1-(1/2)^(1/h)
гдеP
вероятность распада за тик, иh
период полураспада частицы, измеренный в тиках.Нестабильные частицы - первые четыре в списке. Поскольку количество этих частиц определяет, когда заканчивается симуляция, наличие их в начале списка позволяет легко их проверить позже.
Проблема в том, что эта строка огромна - 436 байт! - и использование встроенного сжатия строк в Pyth фактически увеличивает количество байтов, так как в нем используется много многобайтовых символов. Я остановился на относительно простой итеративной схеме сжатия словаря. Фрагмент
u:GhHtHc"xxx"\!"yyy"
распаковывает его следующим образом:Записи в словаре, которые я выбрал, основаны только на моей интуиции и пробах и ошибках, поэтому я уверен, что есть много возможностей для улучшения.
Распакованная словарная строка затем интерпретируется и сохраняется, как описано ниже:
Результатом является то, что
J
упорядоченный список имен частиц. Если они распадаются, имя соединяется с вероятностью его распада и набором частиц, на которые оно может распасться, взвешенных по их относительной вероятности.Определение выходной функции
Это определяет функцию
y(b)
, которая принимает текущее состояние юниверса в качестве входных данных. Это просто список номеров частиц, упорядоченных по их типу, как определено в строке словаря, описанной в предыдущем разделе.Моделирование выполнения
K+Q*]Z24Ws<K4yK=+Z1Vs.em?>O1.0he@JkY,kOee@Jkb<K4IN XhNK_1 XRK1xLGeN;yK%"Simulation ended after %s yoctoseconds."cZT
После завершения подготовки симуляция может быть выполнена. Это состоит из нескольких шагов:
Инициализация вселенной
Поскольку частица с индексом 0 в состоянии юниверса является бозоном Хиггса, начальное состояние юниверса - это массив входных чисел, за которыми следуют 24 нуля.
Цикл моделирования
На каждом тике в симуляции необходимо отображать текущее состояние юниверса, увеличивать счетчик, и каждая летучая частица должна проверять, должна ли она затухать, применяя результаты к состоянию юниверса после оценки каждой частицы.
Окончательный вывод
Моделирование заканчивается, когда не осталось нестабильных частиц. Осталось только вывести окончательное состояние вселенной и сколько времени (сколько тиков) заняло моделирование.
источник
С ++ (
2420,2243,2353,1860, 1822 * .9 = 1639,8)Хорошо, так что это, вероятно, худшая когда-либо представленная кодовая игра в гольф, но это моя первая и мне было весело. Я думаю, что это даже работает. :)
Быстрая версия
Этот не такой короткий (9 дополнительных байтов), но он работает намного быстрее для тестирования огромных чисел. Поскольку он недостаточно короткий, чтобы соревноваться, я также добавил небольшой код, чтобы отследить реальное время выполнения и распечатать его сразу после смоделированного времени. Моя оригинальная версия сделала n = 100k примерно за 8 минут. Версия выше делает это примерно за 2 минуты. Эта быстрая версия может сделать это за 9 секунд. n = 1 миллион потребовалось 53 секунды.
Пример вывода (без аргументов)
Пример вывода (universe.exe 10):
Пример вывода (universe.exe 1000000)
(не совсем 10 ^ 90, но мы добираемся туда)
Большие выходы
Если вы используете консольный вывод из командной строки, я бы предложил что-то вроде этого,
universe.exe 100 > temp.txt
чтобы он шел намного быстрее. С помощью Notepad ++ вы можете затем открыть файл temp.txt, нажать клавишу «Ввод»,ctrl+H
ввести его^(.*?)$\s+?^(?=.*^\1$)
в поле « Найти» , ничего не вводить в поле « Заменить на» , включить режим поиска вRegular Expression
, включить выбор «В» и . соответствует новой строкеOFF
, затем нажмитеReplace All
. Теперь вы просто видите, где произошли изменения, а не 8000 строк вывода (хотя я, похоже, получаю ошибки, выполняющие более 2000-3000 строк одновременно).Исправления / Tweaks
источник
char t[N]={'d','D','u','U','b','B','l','L','c','C','s','S','n','N','m','M','g','G','p','e','E','T','t','Z','W','H'
доchar t[]="dDuUbBlLcCsSnNmMgGpeETtZWH"
? Должен работать в c , не уверен насчет c ++Python 3, 1 247 * 0,9 = 1 122,3
Ну, это моя самая длинная запись, но, по крайней мере, я ниже C ++.
Теперь с добавленным бонусом! Он должен вызываться с номером в качестве первого аргумента.
Моя вселенная не работала с разлагающимися частицами, кроме бозона Хиггса, но теперь работает. Кроме того, у меня не было правильного множественного числа или пунктуации, но я на самом деле делаю это сейчас.
Я получаю так близко к саб 1k!
источник
import random
. Так много для детерминизма.Perl 6 , (707 байт -10%) Оценка 636,3
С некоторыми ненужными переносами строк для большей читабельности:
Попробуйте онлайн!
Некоторое объяснение: Бог и Человек
Есть 2 структуры данных, содержащие физику
%p
и наименование%h
; бог и человек как бы. Физический хеш дает набор строк, проиндексированных оригинальной буквой нестабильной частицы, которые можно разбить, хэшировать и преобразовать в Mix:Каждая частица получает букву, и, таким образом, каждый из этих миксов определяет набор распадов частиц. H распадается на WW с весом вероятности 14.1. Пары частица-античастица кодируются строчными и заглавными буквами, как
c
иC
для очарования кварка и очарования антикварка.И человек немного подумал и назвал это антитавтоном лептоном
Присвоено имя
%h
, которое просто сопоставляет каждую букву с именем частицы. До некоторой степени это игра в гольф, но я подозреваю, что есть место для улучшения, учитывая количество повторений там.Оригинальная строка
С этими двумя структурами, вселенная моделируется, конечно же, манипулированием струнами. Как
"H"
и вселенная с одним бозоном Хиггса. Структура генератора_,_..._
используется для создания цикла и отделяет развивающееся состояние строки юниверса (хранится в$_
) от ее вывода на печать. Печать выполняется путем суммирования букв в юниверсе и составления карты итоговых значений (с множественным числом!).Чихание частиц в бытие
Эволюционирующие частицы включают отображение их на значение, выбранное из Mix для этой частицы; Итак
t
, верхний кварк, развивается какPerl6 позволяет нам случайным образом выбрать один из этих ключей с заданными весами с помощью простого кода
.roll
. Таким образом, мы катимсяt
и получаем, скажем,Wb
и подставляем его в нашу вселенную "HtT" -> "HWbT". Каждая нестабильная частица имеет себя в качестве возможного крена, что позволяет нам упростить структуру по сравнению с необходимостью проверить, распалась она или нет; Большую часть времени вы бросаете на «H», вы просто получаете «H» снова.Экспериментальная теория струн
Вы можете наблюдать эволюцию строки вселенной через эту модифицированную версию .
Представление
Я взял это за 100 H на TIO, и если вы захотите пойти гораздо дальше, неизбежно будет лучше внести некоторые изменения, в конце концов, это теория великих унифицированных строк.
источник
Groovy,
15061454 - 10% = 1309 байтПредполагается, что число начальных частиц бозона Хиггса задается в качестве первого аргумента в командной строке:
источник
PHP, 989 - 10% = 890,1 байта
Саб 1К детка! Спасибо VSZ, это было действительно весело. Так много способов сделать это, и очень трудно проверить правильность вашего вывода.
Программа может принять аргумент командной строки, чтобы указать начальное число бозонов Хиггса, например
php universe_simulator.php 5
Вот то же самое с разрывами строк для ... читабельности ...
Некоторый вывод:
источник
QBasic
2161 * .9 = 19452028 * .9 = 18251854 * .9 = 1669 байтТеперь, когда QBasic - это LOTM, я подумал, что пересмотрю свой самый первый ответ о PPCG. Удалось сбить 140 байтов, неплохо!
Основываясь на отзывах @TaylorScott и @DLosc, я сделал полный редизайн:
Код
Образец вывода
источник
For i=0To 28
x$=Mid$("H00433099979405H004330999550m4H004330998440ZpH004330996210ppH004330980310ZZH004330947610c3H004330877210T2H004330789010ggH004330648010WWH004330000000b12012950666670W12012950333340W82012950000000W70012950666670Wb0012950333340Ws0012950000000WdW0500006666702nW0500003333404nW050000000000+nZ050000882010c3Z050000764010u9Z050000612010b1Z050000460010s8Z050000308010d7Z050000274010T2Z050000240010m4Z050000206010-+Z050000000000n6",15*i+1,15)
...Next
в функцииf$()
над массивомe$()
s$()
,Next:Next
может бытьNext j,i
, и вы должны проверить , чтобы убедиться, что?
заявления нужны все эти;
с. Но также кажется, что ваш вывод не соответствует спецификации в настоящее времяC # 6,
3619361736113586 - 10% = 3227,4 байтаПрограмма принимает два необязательных аргумента для числа начальных бозонов Хиггса и начального числа для использования в классе Random.
Я не должен был использовать объекты для этого, я, вероятно, попытаюсь сделать второе решение, используя вместо этого массивы, но это, вероятно, будет похоже на уже опубликованное решение C ++. Количество бозонов Хиггса, с которыми я могу справиться, также сильно ограничено, я думаю, по крайней мере, час для H = 1 000 000. Меньшие числа работают достаточно хорошо, хотя.
Образец вывода:
Я опубликую последние две строки для прогона h = 1000000, когда он закончится, возможно позже сегодня.Как и обещал:источник
else {U(new T(0>1))
и несколько вn < 2 / 3.0
, и один вn <2/3.0
.if (a.Length
, а другой вif (N[x]!=1
, третий вo+= $
. Кроме того, выa[0]
дважды анализируете целое число, когда результат может быть сохранен в целое число. Я думаю, чтоY==1.0
может бытьY==1.
, но я не уверен в этом.i!=0
может бытьi
. Я не знаю, могут ли ваши переменные на самом деле отрицать, но если нет, вы можете заменить==0
s на<1
. В заголовке должно быть написано C # 6, так как вы используете интерполяцию строк.Mathematica, 950 байт-10% = 855 байт
Использование сжатия выражений:
Несжатый код (1168 байт-10% = 1051,2 байт):
Начальный параметр можно выбрать, изменив значение для a.
Я заметил, что использовал неправильную вероятность для бозона Хиггса, но в настоящее время не могу изменить его (через несколько часов или около того). Поэтому добавьте 3 или 4 байта к текущему решению. (Это был тест-ценность)
источник
Perl
973986959944 байта -10% = 849,6 баллаОтступы и переводы строки не являются частью кода и предоставляются исключительно для того, чтобы вы не прокручивали 30 лет, чтобы прочитать все это.
Есть пара 0-байтовых оптимизаций, которые я никогда не пытался отменить.
Очевидно, основная часть кода создает начальные хэши.
%p
содержит имена всех частиц, использующих функцию голого слова в Perl.%r
определяет скорость распада. Если это не показано здесь, тогда это не гниет вообще.%d
содержит частицы распада.Поскольку порядок частиц в выходных данных не имеет значения, я не беспокоюсь о том, чтобы изменить его со случайного способа, которым Perl обращается к ключам в хэше, что приводит к следующим вещам:
Это действительно было волнующее приключение. Чудесная головоломка, если честно, мне было очень весело! :)
источник
Python 3.6.1,
11831157...905889 * 0,9 = 800,1 байтаВпервые представив один из них, но этот вызов выглядел довольно забавно, так что поехали ...
Почти наверняка не так хорошо, как могло бы быть, но я довольно неопытен в этом, поэтому любые советы приветствуются.
Попробуйте онлайн!
Изменить: В интересах краткости, сокращенный список правок, которые я сделал (спасибо комментаторам за помощь!):
random.choices()
взвешенные вероятности, а не проценты, так что я мог бы сэкономить несколько байтов, сдвинув их на несколько степеней от десяти до 28 сохраненных байтов! Вероятность распада Хиггса была неправильной - я прочитал 0,43% вместо 0,043%, что стоило два байта.any()
,+=
вместо того ,list.extend()
и другогоimport
заявления.choices(*p[x][1:])
для спасения пары иx and y or z
избеганияif...else...or
.enumerate()
копированием юниверса и использованиемlist.remove()
оригинала (enumerate
любом случае метод был нарушен).print()
утверждение и объединенныеif
утверждения. Убраны некоторые ненужные скобки.Более читаемая версия:
Пример вывода с 5000 бозонами Хиггса - возможно, сделаем еще больший прогон позже, чтобы увидеть, не произойдет ли какой-либо распад верхнего кварка:
Если я сделал что-то не так, пожалуйста, дайте мне знать, и я постараюсь это исправить!
источник
Рубин,
997995 байт -10% = 895,5 баллаedit: добавлено 'и' в качестве последнего разделителя, как замечено хлебной коробкой
Первое опубликование на PPCG, это старая проблема, но мне было очень весело делать это. Вот код
Строки сжимаются путем разложения повторяющихся слов (vars
s
иt
). Продукты распада хранятся компактно как строка (varr
), каждая буква является частицей. Функцияf
печатает состояние юниверса, отображая массив частиц в строки. Я чувствую, что в строке обновления состояния нужно обрезать несколько байтов, но я не могу найти ничего лучше.Пример вывода
Представление
Это не так плохо! Он вычислил 100000 бозона Хиггса за 25 секунд
источник
>
в вашемwhile
? Я давно уже ничего не делал в Ruby.D
11721101 байт - 10% = 990,9 байтUngolfed
источник
Котлин : 1330 - 10% = 1197 байт
Моя первая в истории подача кода в гольф; очень неэффективно из-за того, что списки более привлекательны, чем карты, но, похоже, правильны! Работает над реализацией JVM или JS и принимает (необязательный) аргумент.
Менее гольф-версия
источник
Довольно долгая подача.
Не так много в гольфе, но все же короче, чем другой питон.
Возьмите начальное количество Хиггса в качестве входных данных.
Python 3 ,
11341120 байт - 10% =1020,61008 балловПопробуйте онлайн!
источник
F #,
1993 г.1908 байт - 10% = 1718 байтПопробуйте онлайн!
Без швов это выглядит так:
источник