Гольф число больше номера погрузчика


18

В качестве продолжения завершающей программы Shortest, выходной размер которой превышает число Грэма, а Golf - число больше, чем TREE (3) , я представляю новую задачу.

Номер загрузчика очень большой, его сложно объяснить (так как он сам был результатом упражнения в гольф-коде с гибкой целью). Существует определение и объяснение здесь , но для целей замкнутости, я попытаюсь объяснить это позже в этой должности , а также.

Алгоритм, который использовал Ralph Loader, дает одно из самых больших чисел среди всех (вычислимых) алгоритмов, когда-либо написанных! Действительно, число загрузчика является самым большим «вычислимым» числом в вики-сайте Googology. (Под «вычислимым» числом они подразумевают число, определенное в терминах вычислений.) Это означает, что если ответ производит интересное число, большее числа загрузчика (т.е. не только число загрузчика + 1), вы можете перейти в История гугологии! При этом программы, которые выдают что-то вроде номера загрузчика + 1 , безусловно, являются верными ответами и претендентами на этот вопрос; просто не жди славы.

Ваша задача состоит в том, чтобы создать завершающую программу, которая выдает число, превышающее число загрузчика. Это , поэтому выигрывает самая короткая программа!

  • Вы не можете принимать участие.
  • Ваша программа должна в конечном итоге завершиться детерминистически, но вы можете предположить, что машина имеет бесконечную память.
  • Вы можете предположить, что тип числа вашего языка может содержать любое конечное значение, но вам нужно объяснить, как именно это работает в вашем языке (например: имеет ли плавание бесконечную точность?)
    • Бесконечности не допускаются как выходные данные.
    • Недостаток числового типа вызывает исключение. Это не обернуть вокруг.
  • Вы должны предоставить объяснение того, почему ваш номер такой большой, и версию вашего кода, на которую не обращали внимания, чтобы проверить, действительно ли ваше решение действительно (так как нет компьютера с достаточным объемом памяти для хранения номера загрузчика).

Итак, вот объяснение номера загрузчика. См. Http://googology.wikia.com/wiki/Loader%27s_number и ссылки в нем для более точной информации. В частности, он содержит программу, которая выдает номер загрузчика точно (по определению).

Исчисление конструкций по существу является языком программирования с очень особыми свойствами.

Прежде всего, любая синтаксически допустимая программа завершается. Там нет бесконечных петель. Это будет очень полезно, потому что это означает, что если мы запустим программу произвольного исчисления конструкций, наша программа не застрянет. Проблема в том, что это означает, что исчисление конструкций не является полным по Тьюрингу.

Во-вторых, среди нетуринговых полных языков он является одним из самых мощных. По сути, если вы можете доказать, что машина Тьюринга будет останавливаться на каждом входе, вы можете запрограммировать функцию в исчислении конструкций, которая будет имитировать ее. (Это не делает его тьюринг завершенным, потому что есть машины остановки, которые вы не можете доказать, останавливаются.)

Номер загрузчика - это, по сути, номер занятого бобра для исчисления конструкций, который можно вычислить, поскольку все программы coc завершаются.

В частности, loader.c определяет вызываемую функцию D. Приблизительно, D(x)итерирует по всем битовым строкам меньше, чем x, интерпретирует их как кок-программы, запускает синтаксически допустимые и объединяет результаты (которые также будут битовыми строками ). Возвращает это объединение.

Номер загрузчика есть D(D(D(D(D(99))))).

Более читаемая копия кода из вики по googolology

int r, a;

P(y,x){return y- ~y<<x;}

Z(x){return r = x % 2 ? 0 : 1 + Z (x / 2 );}

L(x){return x/2 >> Z(x);}

S(v,y,c,t){
   int f = L(t);         
   int x = r;
   return f-2 ? f>2 ? f-v ? t-(f>v)*c : y : P(f,P(S(v,y,c,L(x)), S(v+2,t=S(4,13,-4,y),c,Z(x)))) : A(S(v,y,c,L(x)),S(v,y,c,Z(x)));
}

A(y,x){return L(y)-1 ? 5<<P(y,x) : S(4,x,4,Z(r));}

D(x) 
{
   int f;
   int d;
   int c=0;
   int t=7;
   int u=14;
   while(x&&D(x-1),(x/=2)%2&&(1)){
      d = L(L(D(x))),
      f = L(r),
      x = L(r),
      c - r||(L(u)||L(r)-f||(x/=2)%2&&(u=S(4,d,4, r),t=A(t,d)),f/2&(x/=2)%2&&(c=P(d,c),t=S(4,13,-4,t),u=S(4,13,-4,u))),
      c&&(x/=2)%2&&(t=P(~u&2|(x/=2)%2&&(u=1<<P(L(c),u)),P(L(c),t)),c=r)
      u/2&(x/=2)%2&&(c=P(t,c),u=S(4,13,-4,t),t=9);
    }
    return a = P( P( t, P( u, P( x, c)) ),a);
}

main(){return D(D(D(D(D(99)))));}

6
Я бы посоветовал не понижать это, поскольку это похоже на вопрос о TREE (3): число загрузчиков намного больше, чем у TREE (3), поэтому требуются новые и интересные подходы.
lirtosiast

2
@ fəˈnɛtɪk Что ж, печать номера загрузчика + 1 все еще интересна с точки зрения гольф-кода (например, можете ли вы превзойти исходные 512 байт?) Существуют также некоторые естественные обобщения номера загрузчика, которые могут быть проще реализовать (например, используя ZFC вместо CoC). Кроме того, можно использовать последовательности жадных кликов или игры с конечным обещанием.
PyRulez

2
К сожалению, поскольку я не понимаю, как строится число Лоадера, и, похоже, нет известных верхних границ в терминах быстро растущей иерархии, я не могу дать здесь хороших ответов. Я полагаю, что большинство ответов будет либо расширением числа Лоадера, либо такими вещами, как жадные клики и игры с конечными обещаниями ...
Simply Beautiful Art

1
@SimplyBeautifulArt О, парень, если ты этого не понимаешь, это не сулит ничего хорошего для этой задачи. PI может попытаться объяснить это более подробно вам в чате, но я также не знаю каких-либо верхних границ иерархии.
PyRulez

1
@SimplyBeautifulArt В частности, поскольку константа Loader была специально выбрана, чтобы попытаться стать наибольшим числом, генерируемым определенным количеством кода (где в качестве числа Грэма и TREE (3) просто математически интересные числа, которые так уж оказываются большими), я думаю, что большинство ответов будет просто числом загрузчика + 1.
PyRulez

Ответы:


9

JavaScript, D ^ 6 (9) ( 508 501 495 492 487 485 481 байт)

_='r=a=0,PN,yEx-~x<<y,ZNEr=x%2?0:1+ZC>>1@LNEx/2>>ZC@S=Bt,f=Ht@x=rEf-2?f>2?f-v?t-(f>v)*c:y:Ff,FSO(v+2,t8y@c,ZCMM:A(AOBZC)GAN,yELC)-1?5<<PC,y):Iy,4,Z(rGDN,f,dQ=0,t=7,u=14Eeval("whileC&&DC-1@61Md=HHDC)Gf=Hr@x=Hr@c-r||(Hu)||Hr)-f||6u=Id,4,r@t=A(t,dGfJdQ@t8t@u8u)Gc&&6t=F~u&2|6u=1<<FHc@uGFHc@tGc=r@uJtQ@u8t@t=9);a=FFt,Fu,PCQ)Ga)"@KKK9MMM6C>>=1)%2&&(8=I13,-4,G)@@),B(v,yQ,N=COBLCGSC(xE)=>J/2&6c=FFP(HL(IS(4,KD(D(M))Q,c';for(Y of $='QMKIHFJECONB@G86')with(_.split(Y))_=join(pop());eval(_)

Это кодированный код.

_='r=a=0,PN,yEx-~x<<y,ZNEr=x%2?0:1+ZC>>1@LNEx/2>>ZC@S=Bt,f=Ht@x=rEf-2?f>2?f-v?t-(f>v)*c:y:Ff,FSO(v+2,t8y@c,ZCMM:A(AOBZC)GAN,yELC)-1?5<<PC,y):Iy,4,Z(rGDN,f,dQ=0,t=7,u=14Eeval("whileC&&DC-1@61Md=HHDC)Gf=Hr@x=Hr@c-r||(Hu)||Hr)-f||6u=Id,4,r@t=A(t,dGfJdQ@t8t@u8u)Gc&&6t=F~u&2|6u=1<<FHc@uGFHc@tGc=r@uJtQ@u8t@t=9);a=FFt,Fu,PCQ)Ga)"@KKK9MMM6C>>=1)%2&&(8=I13,-4,G)@@),B(v,yQ,N=COBLCGSC(xE)=>J/2&6c=FFP(HL(IS(4,KD(D(M))Q,c'; //encoded code
for(Y of $='QMKIHFJECONB@G86')with(_.split(Y))_=join(pop()); //decoding algorithm
eval(_) //Evaluation of the string

Декодированный код:

r=a=0,P=(x,y)=>x-~x<<y,Z=(x)=>r=x%2?0:1+Z(x>>1),L=(x)=>x/2>>Z(x),S=(v,y,c,t,f=L(t),x=r)=>f-2?f>2?f-v?t-(f>v)*c:y:P(f,P(S(v,y,c,L(x)),S(v+2,t=S(4,13,-4,y),c,Z(x)))):A(A(v,y,c,L(x)),S(v,y,c,Z(x))),A=(x,y)=>L(x)-1?5<<P(x,y):S(4,y,4,Z(r)),D=(x,f,d,c=0,t=7,u=14)=>eval("while(x&&D(x-1),(x>>=1)%2&&(1))d=L(L(D(x))),f=L(r),x=L(r),c-r||(L(u)||L(r)-f||(x>>=1)%2&&(u=S(4,d,4,r),t=A(t,d)),f/2&(x>>=1)%2&&(c=P(d,c),t=S(4,13,-4,t),u=S(4,13,-4,u))),c&&(x>>=1)%2&&(t=P(~u&2|(x>>=1)%2&&(u=1<<P(L(c),u)),P(L(c),t)),c=r),u/2&(x>>=1)%2&&(c=P(t,c),u=S(4,13,-4,t),t=9);a=P(P(t,P(u,P(x,c))),a)"),D(D(D(D(D(D(9))))))

Декодированный, негольфированный код (условия и прочее хранятся в loader.c):

var r=a=0;
function P(y,x){
  return y-~y<<x;
}
function Z(x){
  return r=x%2?0:1+Z(x>>1);
}
function L(x){
  return x/2>>Z(x);
}
function S(v,y,c,t){
  var f=L(t),x=r;
  return f-2?
           f>2?
             f-v?
               t-(f>v)*c
               :y
             :P(f,P(S(v,y,c,L(x)),S(v+2,t=S(4,13,-4,y),c,Z(x))))
           :A(S(v,y,c,L(x)),S(v,y,c,Z(x)))
}
function A(y,x){
  return L(y)-1?
         5<<P(y,x):
         S(4,x,4,Z(r));
}
function D(x){
  var f,
      d,
      c=0,
      t=7,
      u=14;
  while(x&&D(x-1),(x>>=1)%2&&(1))
    d=L(L(D(x))),
    f=L(r),
    x=L(r),
    c-r||(
      L(u)||L(r)-f||
      (x>>=1)%2&&(
        u=S(4,d,4,r),t=A(t,d)
      ),
      f/2&(x>>=1)%2&&(
        c=P(d,c),
        t=S(4,13,-4,t),
        u=S(4,13,-4,u)
      )
    ),
    c&&(x>>=1)%2&&(
      t=P(
        ~u&2|(x>>=1)%2&&(
          u=1<<P(L(c),u)
        ),
        P(L(c),t)
      ),
      c=r
    ),
    u/2&(x>>=1)%2&&(
      c=P(t,c),
      u=S(4,13,-4,t),
      t=9
    );
  return a=P(P(t,P(u,P(x,c))),a)
};
D(D(D(D(D(D(9))))))

В этом предполагается, что:

  • Бесконечный стек вызовов
  • Бесконечная память
  • Бесконечная точность Number
  • Бесконечная величина Number
  • Операции Bitshift и побитовые операции работают с бесконечными битами, а не с 53 битами. Побитовое отрицание все еще отрицает знаковый бит.

Алгоритм кодирования / декодирования:

Кодировка выполняется следующим образом:

  • Возьми повторяющуюся строку, назови ее S.
  • Замените все S в коде на ключ K.
  • Поместите K и S в конце.
  • Составьте список ключей, а также поместите алгоритм декодирования, чтобы код действительно работал.

Алгоритм декодирования:

  • Взять список ключей.
  • Возьмите самый ранний ключ К.
  • Разделить строку для каждого К.
  • Поскольку последний из массива - это то, что нужно заменить KS, вытолкните его и замените все K, соединив массив с вытянутым значением S.

Сжатие было сделано с этим кодом , отметьте только последний флажок. Так как это сначала закодирует наибольшее сохранение, это не самое эффективное сжатие, но я тоже не знаю, как сделать его меньше.

JavaScript, (339 символов )

eval("_㴧爽愽〬偍ⱹ䕸⵾砼㱹ⱚ䵅爽砥㈿〺ㄫ婃㸾ㅀ䱍䕸⼲㸾婃䁓㵂琬昽䡴䁸㵲䕦ⴲ㽦㸲㽦⵶㽴⴨显瘩⩣㩹㩆昬䙓丨瘫㈬琸祀挬婃䭋㩁⡁乂婃⥇䅍ⱹ䕌䌩ⴱ㼵㰼偃ⱹ⤺匨㐬礬㐬娨片䑍ⱦⱤⱣ㴰ⱴ㴷Ⱶ㴱㑅敶慬⠢睨楬敃☦䑃ⴱ䀶ㅋ搽䡈䑃⥇昽䡲䁸㵈牀挭牼簨䡵⥼籈爩ⵦ籼㙵㵓⠴ⱤⰴⱲ䁴㵁⡴Ɽ䝦䥤Ᵽ䁴㡴䁵㡵⥇挦☶琽䙾甦㉼㙵㴱㰼䙈捀畇䙈捀瑇挽牀畉琬捀甸瑀琽㤩㭡㵆䙴ⱆ甬偃Ᵽ⥇愩≀䩊䨹䭋䬶䌾㸽ㄩ┲☦⠸㵓⠴ⰱ㌬ⴴⱇ⥀䀩ⱂ⡶ⱹⱣⱍ㵃乂䱃䝓䌨硅⤽㹉⼲☶挽䙆倨䡌⡊䐨䐨䬩⤧㭦潲⡙映␽❋䩈䙉䕃乍䉀䜸㘧⥷楴栨弮獰汩琨天⥟㵪潩渨灯瀨⤩㭥癡氨弩".split``.map(a=>(d=String.fromCharCode)((c=a.charCodeAt())>>8)+d(c&255)).join``.slice(1))

Этот код примет 16-битную строку как a, преобразует ее в 8-битную строку с тем же двоичным кодом (BE) и evalэтим.

Декодированный код является закодированным кодом выше.

Доказательство того, что D ^ 6 (9)> D ^ 5 (99)

Для этого мы бы сравнили D (9) и 99.

При ручном запуске кода D (9) оказывается равным (15*2^14849+1)*2^((15*2^14849+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^929+1)*2^((15*2^929+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^((15*2^59+1)*2^(15*2^59+1)))))))))))))))))))))))))))))))), а даже D (0) равно 8646911284551352321.

Итак, D (9) >>> 99, а поскольку D строго возрастает, D ^ 6 (9)> D ^ 5 (99).

  • 508B-> 501B, -7B
    • -1B за ... я не знаю почему. Я изменился D(D(D(D(D(99)))))на D(D(D(D(D(D(9)))))). Также это перемешало буквы.
    • -6B для повторного добавления &&(1)для D(x)условия цикла.
  • 501B-> 495B, -6B
    • Исправлено большинство /2s в >>1s, потому чтоNumber
    • 6 байт сохраняют откуда-то
    • Вы можете увидеть мою попытку в этом обновлении здесь
  • 495-> 492B, -3B
    • Меняя декодер с for...inна for...of.
  • 492-> 487B, -5B
    • Удаление ненужных заданий
    • Изменение имен аргументов
  • 487-> 485B, -2B
    • 1 байт от использования evalдля Dудаления return.
    • 1-байтовое сжатие, объединяющее закрывающие скобки в запятую.
  • 485-> 481B, -4B
    • Сжимая разные подстроки.

Или легко передать его с равной длиной, заменив 99 на M9, что дает значение D ^ 6 (9).
Наруйоко,

0

Python 3, D ^ 6 (9) ( 608 600 599 байт)

_='r=a=0?CM:#y-~y<<x?H6@r=0.EB1+HI)#r?Fx):#xI>>H)?8t6@TtNr#A(U8HG).f==2BCf,CUS(v+2,/yNc,HGG.f<2Bt-(f>v)*c.f-vBy?A(M:#5<<CM.Fy)-1BOx,4,Z(rG?Jx6,a@f=d=c=0@VW7,14@while 1:@.x:Jx-1)X~E:breakKd,TFJxGNFrNFr)@.c-r:K.not(Fu)or(Fr)-fGQ.E:WOd,4,rRA(Vd)K.fIQ.Yd,cR/t);W/u)@.c:@!.EQ q=~u&2|EK .q:W1<<CFuNu)K  Vc=Cq and u,CFcNtG,rXuI&YVc);W/tR9@a=CCVCu,Cx,cGNa)#a\nprint(JJJJJJ9GGG)X\n!if !  x=xIK#@return . if /O13,-4,6):@global r8S(v,y,c,?\ndef Q:K! K@ @\n B else CP(YE:c=CEx%2Tf,x=FFL(U8FxG,G))HZ(xI>>1JD(My,x)N),OS(4,R);t=Vt,Wu='
for Y in 'WVRONMJIHGUFTEYCB@KQ?86/.#!X':_=_.split(Y);_=_.pop().join(_)
exec(_)

Это кодированный код. Выдержки:

r=a=0
def P(y,x):
 return y-~y<<x
def Z(x):
 global r
 r=0 if x%2 else 1+Z(x>>1)
 return r
def L(x):
 return x>>1>>Z(x)
def S(v,y,c,t):
 global r
 f,x=L(t),r
 return A(S(v,y,c,L(x)),S(v,y,c,Z(x))) if f==2 else P(f,P(S(v,y,c,L(x)),S(v+2,S(4,13,-4,y),c,Z(x)))) if f<2 else t-(f>v)*c if f-v else y
def A(y,x):
 return 5<<P(y,x) if L(y)-1 else S(4,x,4,Z(r))
def D(x):
 global r,a
 f=d=c=0
 t,u=7,14
 while 1:
  if x:D(x-1)
  x=x>>1
  if ~x%2:break
  d,f,x=L(L(D(x))),L(r),L(r)
  if c-r:
   if not(L(u)or(L(r)-f)):
    x=x>>1
    if x%2:u=S(4,d,4,r);t=A(t,d)
   if f>>1:
    x=x>>1
    if x%2:c=P(d,c);t=S(4,13,-4,t);u=S(4,13,-4,u)
  if c:
   x=x>>1
   if x%2:
    x=x>>1
    q=~u&2|x%2
    if q:u=1<<P(L(u),u)
    t,c=P(q and u,P(L(c),t)),r
  x=x>>1
  if u>>1&x%2:c=P(t,c);u=S(4,13,-4,t);t=9
 a=P(P(t,P(u,P(x,c))),a)
 return a
print(D(D(D(D(D(D(9)))))))

В этом предполагается, что:

  • Бесконечный стек вызовов
  • Бесконечная память

Это в основном порт моего ответа JavaScript . Для более подробной информации, проверьте это.

Сжатие было сделано с этим .

Я не очень хорошо осведомлен в Python, поэтому, безусловно, есть места для сохранения байтов. Я думаю, что суб-600 возможно. суб-600 был доказан.

  • 608-> 600В, -8В
    • Сгруппированы некоторые задания
    • Обратные условия Sдля уменьшения скобок
  • 600-> 599B, ​​-1B
    • Изменение u/2в третьей последней строке определения Dto u>>1, сохранение байта от сжатия его до символа с другими >>1s.

0

Рубин, D ^ 6 (9) (553 байта)

_='F=$a=0TEK#y-~yUx.Z@#F=x%2G1?0R1+Z(x/2).L@#x/2>>Z@.8t)VHt);x=F#fG2?A(8L@C8Z@IRf>2?fGv ?yRt-(f>v ?1R0)*cREf,E8L@CS(v+2,t6yCc,Z@I).A(K#Hy)G1?Mx,4,Z(FIR5UEK.D@;$>UxVd=c=0;t=7;u=14;while[xNOx-1CB>0][1];d=HHD@IVW;x=W;cGF&&[Hu)G0&&WGf&&![u=Md,4,FCt=A(t,d)],fJd,cCt6tCu6u)]];cNB&&[t=E~u&2|!(u=1UEHcCu)CEHcCt)Cc=F];uJt,cCu6tCt=9]Q#$a=EEt,Eu,Ex,cIC$a)Q;$>UOOOOOO9III!BN#;return .QT6=M13,-4,8S(v,y,c,@(x)B(x/=2)%2C),J/2&![c=EEP(F$rNG0||G==WHF)HL(I))Ky,x)MS(4,OD(Q;endR: T;def U<<V;f=VUTRQOMKIHWGNFEJCB@86.#!'.each_char{|Y|_=_.split(Y);_=_.join(_.pop())};eval(_)

Это кодированный код. Выдержки:

$r=$a=0;def P(y,x);return y-~y<<x;end;def Z(x);return $r=x%2==1?0: 1+Z(x/2);end;def L(x);return x/2>>Z(x);end;def S(v,y,c,t);f=L(t);x=$r;return f==2?A(S(v,y,c,L(x)),S(v,y,c,Z(x))): f>2?f==v ?y: t-(f>v ?1: 0)*c: P(f,P(S(v,y,c,L(x)),S(v+2,t=S(4,13,-4,y),c,Z(x))));end;def A(y,x);return L(y)==1?S(4,x,4,Z($r)): 5<<P(y,x);end;def D(x);$><<x;f=d=c=0;t=7;u=14;while[x==0||D(x-1),(x/=2)%2>0][1];d=L(L(D(x)));f=L($r);x=L($r);c==$r&&[L(u)==0&&L($r)==f&&(x/=2)%2==0||[u=S(4,d,4,$r),t=A(t,d)],f/2&(x/=2)%2==0||[c=P(d,c),t=S(4,13,-4,t),u=S(4,13,-4,u)]];c==0||(x/=2)%2&&[t=P(~u&2|(x/=2)%2==0||(u=1<<P(L(c),u)),P(L(c),t)),c=$r];u/2&(x/=2)%2==0||[c=P(t,c),u=S(4,13,-4,t),t=9];end;return $a=P(P(t,P(u,P(x,c))),$a);end;$><<D(D(D(D(D(D(9))))))

Этот код является номером загрузчика с D 6 (9) вместо.

В этом предполагается, что:

  • Бесконечный стек вызовов
  • Бесконечная память

Это в основном порт моего ответа на JavaScript и Python 3 ответов . Для более подробной информации, проверьте их.

Сжатие было сделано с этим (может появиться, поскольку это не существует).

Я новичок в Ruby, так что, возможно, под 512 возможно, но я сомневаюсь в этом.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.