Як подальша робота із найкоротшою програмою, що закінчується, розмір виходу якої перевищує кількість Грема, а Golf - на номер, більший за TREE (3) , я представляю нове завдання.

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

Використовуваний алгоритм Ralph Loader виробляє одне з найбільших чисел будь-якого (обчислюваного) алгоритму, коли-небудь написаного! Дійсно, номер навантажувача є найбільшим "обчислювальним" числом у Googology Wiki. (Під "обчислювальним" числом вони означають число, визначене за допомогою обчислення.) Це означає, що якщо відповідь цікавим чином створює число, що перевищує число навантажувача (тобто не лише номер навантажувача + 1), ви можете спуститися в Історія гогології! Незважаючи на це, програми, що створюють щось на зразок числа завантажувача + 1 , безумовно, є правильними відповідями та претендентами на це питання; просто не сподівайся на славу.

Ваше завдання полягає в створенні програми , яка виробляє завершальне число більше ніж число заряджає. Це код-гольф , тому найкоротша програма виграє!

• Вам не дозволяється приймати дані.
• Зрештою, ваша програма повинна припинити детерміновано, але ви можете припустити, що машина має нескінченну пам'ять.
• Ви можете припустити, що тип вашої мови може містити будь-яке кінцеве значення, але потрібно пояснити, як саме це працює у вашій мові (напр .: чи має float нескінченну точність?)
  • Нескінченності не допускаються як вихід.
  • Під переповненням чисельного типу є виняток. Він не загортається.
• Потрібно надати пояснення, чому ваш номер настільки великий, і неперероблену версію коду, щоб перевірити, чи ваше рішення є дійсним (оскільки немає комп’ютера з достатньою пам’яттю, щоб зберігати номер навантажувача).

Отож ось пояснення номера навантажувача. Детальнішу інформацію див. У розділі http://googology.wikia.com/wiki/Loader%27s_number та посилання на них. Зокрема, вона містить програму, яка точно виробляє номер завантажувача (за визначенням).

Обчислення конструкцій по суті є мовою програмування з дуже особливими властивостями.

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

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

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

Зокрема, 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)))));}

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.
• Складіть список ключів, а також поставте алгоритм декодування, щоб код фактично працював.

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

• Візьміть список ключів.
• Візьміть найдавніший ключ К.
• Розділіть рядок для кожного K.
• Оскільки останній масив - це те, що замінити 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)умови циклу 's.
• 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
  • Стискаючи різні підрядки.

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-> 599В, -1В
  • Зміна u/2в третьому останньому рядку визначення Dдо u>>1, збереження байту від стиснення його до символу з іншими >>1s.

Ruby, 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 ⁶ натомість (9).

У цьому передбачається:

• Нескінченний стек викликів
• Нескінченна пам'ять

Це в основному порт моєї відповіді на JavaScript і відповіді Python 3 . Щоб отримати детальнішу інформацію, перевірте їх.

Стиснення було зроблено за допомогою цього (може з’явитися так, як його немає).

Я початківець в Ruby, тому, можливо, під 512 це можливо, але я сумніваюся в цьому.