Theo chương trình chấm dứt ngắn nhất có kích thước đầu ra vượt quá số của Graham và Golf lớn hơn TREE (3) , tôi đưa ra một thách thức mới.

Số lượng của Loader là một con số rất lớn, rất khó để giải thích (vì chính nó là kết quả của một bài tập golf mã với mục tiêu linh hoạt). Có một định nghĩa và giải thích ở đây , nhưng với mục đích tự ngăn chặn, tôi cũng sẽ cố gắng giải thích nó sau trong bài viết này.

Thuật toán Ralph Loader được sử dụng tạo ra một trong những số lớn nhất của bất kỳ thuật toán (tính toán) nào từng được viết! Thật vậy, số của Loader là số "tính toán" lớn nhất trên Wiki của Googology. (Theo số "có thể tính toán", chúng có nghĩa là một số được xác định theo thuật toán.) Điều đó có nghĩa là nếu câu trả lời tạo ra một số lớn hơn số của Trình tải theo cách thú vị (không chỉ là số của Trình tải + 1), bạn có thể truy cập vào Lịch sử địa lý! Điều đó đang được nói, các chương trình tạo ra thứ gì đó như số 1 ​​của Loader chắc chắn là câu trả lời hợp lệ và là ứng cử viên cho câu hỏi này; chỉ không mong đợi bất kỳ danh tiếng.

Công việc của bạn là tạo một chương trình kết thúc tạo ra một số lớn hơn số của Loader. Đây là môn đánh gôn , vì vậy chương trình ngắn nhất sẽ thắng!

• Bạn không được phép lấy đầu vào.
• Chương trình của bạn cuối cùng phải chấm dứt một cách xác định nhưng bạn có thể giả sử máy có bộ nhớ vô hạn.
• Bạn có thể cho rằng loại số ngôn ngữ của bạn có thể giữ bất kỳ giá trị hữu hạn nào nhưng cần giải thích chính xác cách thức hoạt động của ngôn ngữ này (ví dụ: một số float có độ chính xác vô hạn?)
  • Infinities không được phép là đầu ra.
  • Dòng dưới của một loại số ném một ngoại lệ. Nó không quấn quanh.
• Bạn cần đưa ra lời giải thích về lý do tại sao số của bạn quá lớn và phiên bản mã không được mã hóa để kiểm tra xem giải pháp của bạn có hợp lệ không (vì không có máy tính nào có đủ bộ nhớ để lưu số của Loader).

Vì vậy, đây là một lời giải thích về số của Loader. Xem http://googology.wikia.com/wiki/Loader%27s_number và các liên kết trong đó để biết thêm chi tiết chính xác. Cụ thể, nó chứa một chương trình tạo ra chính xác số của Loader (theo định nghĩa).

Tính toán của các công trình xây dựng về cơ bản là một ngôn ngữ lập trình với các thuộc tính rất đặc biệt.

Trước hết, mọi chương trình có giá trị cú pháp đều chấm dứt. Không có vòng lặp vô hạn. Điều này sẽ rất hữu ích, bởi vì điều đó có nghĩa là nếu chúng ta chạy một phép tính tùy ý của chương trình xây dựng, chương trình của chúng ta sẽ không bị kẹt. Vấn đề là điều này hàm ý việc tính toán các công trình chưa hoàn thành.

Thứ hai, trong số các ngôn ngữ hoàn chỉnh không Turing, nó là một trong những ngôn ngữ mạnh nhất. Về cơ bản, nếu bạn có thể chứng minh rằng máy Turing sẽ dừng trên mọi đầu vào, bạn có thể lập trình một hàm trong phép tính của các công trình sẽ mô phỏng nó. (Điều này không làm cho nó hoàn chỉnh, bởi vì có những máy xử lý tạm dừng mà bạn không thể chứng minh được đang tạm dừng.)

Số của Loader về cơ bản là một số hải ly bận rộn để tính toán các công trình, có thể tính toán vì tất cả các chương trình coc chấm dứt.

Cụ thể, loader.c định nghĩa một hàm gọi là D. Xấp xỉ, D(x)lặp đi lặp lại trên tất cả các chuỗi bit ít hơn x, diễn giải chúng như một chương trình coc, chạy các chuỗi có hiệu lực về mặt cú pháp và nối các kết quả (cũng sẽ là bitstrings). Nó trả lại kết nối này.

Số của Loader là D(D(D(D(D(99))))).

Một bản sao dễ đọc hơn của mã từ wiki 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 byte)

_='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(_)

Đây là một mã được mã hóa.

_='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

Mã giải mã:

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

Mã được giải mã, không mã hóa (điều kiện và nội dung được giữ từ 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))))))

Trong đó, nó được coi là:

• Ngăn xếp cuộc gọi vô hạn
• Bộ nhớ vô hạn
• Độ chính xác vô hạn Number
• Độ lớn vô hạn Number
• Toán tử bit và bitwise hoạt động trên các số nguyên bit vô hạn thay vì 53 bit. Phủ định bitwise vẫn phủ định bit dấu.

Thuật toán mã hóa / giải mã:

Việc mã hóa được thực hiện như sau:

• Lấy một chuỗi lặp lại, gọi nó là S.
• Thay thế tất cả S trong mã thành khóa K.
• Đặt K và S ở cuối.
• Tạo một danh sách các khóa và cũng đặt thuật toán giải mã để mã thực sự chạy.

Thuật toán giải mã:

• Lấy danh sách các phím.
• Lấy chìa khóa sớm nhất K.
• Tách chuỗi cho mỗi K.
• Vì cuối cùng của mảng là những gì cần thay thế KS, bật nó và thay thế tất cả K bằng cách nối mảng với giá trị popped S.

Việc nén đã được thực hiện với mã này , chỉ chọn hộp cuối cùng. Vì điều này sẽ mã hóa lần lưu lớn nhất trước tiên, nó không phải là cách nén hiệu quả nhất, nhưng tôi không biết làm thế nào để làm cho nó nhỏ hơn nữa.

JavaScript, (339 ký tự )

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

Mã này sẽ lấy chuỗi 16 bit làm a, chuyển đổi nó thành chuỗi 8 bit có cùng nhị phân (BE) và evalnó.

Mã được giải mã là mã được mã hóa ở trên.

Chứng minh rằng D ^ 6 (9)> D ^ 5 (99)

Đối với điều này, chúng tôi sẽ so sánh D (9) và 99.

Bằng cách chạy mã thủ công, D (9) được tìm thấy bằng (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))))))))))))))))))))))))))))))))và thậm chí D (0) bằng 8646911284551352321.

Vì vậy, D (9) >>> 99 và vì D đang tăng nghiêm ngặt, D ^ 6 (9)> D ^ 5 (99).

• 508B-> 501B, -7B
  • -1B cho ... Tôi không biết tại sao. Tôi đã thay đổi D(D(D(D(D(99)))))để D(D(D(D(D(D(9)))))). Ngoài ra mà xáo trộn các chữ cái.
  • -6B để thêm lại &&(1)cho D(x)điều kiện vòng lặp.
• 501B-> 495B, -6B
  • Đã sửa hầu hết /2s thành >>1s vìNumber
  • Lưu 6 byte từ đâu đó
  • Bạn có thể thấy nỗ lực của tôi trong bản cập nhật này ở đây
• 495-> 492B, -3B
  • Bằng cách thay đổi bộ giải mã từ for...insang for...of.
• 492-> 487B, -5B
  • Loại bỏ các bài tập không cần thiết
  • Thay đổi tên đối số
• 487-> 485B, -2B
  • 1 byte từ việc sử dụng evalcho D, loại bỏ return.
  • Nén 1 byte kết hợp các dấu ngoặc đơn đóng thành dấu phẩy.
• 485-> 481B, -4B
  • Bằng cách nén các chất nền khác nhau.

Python 3, D ^ 6 (9) ( _{608 600} 599 byte)

_='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(_)

Đây là một mã được mã hóa. Trích xuất:

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

Trong đó, nó được coi là:

• Ngăn xếp cuộc gọi vô hạn
• Bộ nhớ vô hạn

Đây về cơ bản là một cổng của câu trả lời JavaScript của tôi . Để biết thêm chi tiết, kiểm tra cái đó.

Việc nén đã được thực hiện với điều này .

Tôi không rành về Python, vì vậy chắc chắn có những nơi để lưu byte. Tôi nghĩ rằng phụ 600 là có thể. tiểu 600 đã được chứng minh.

• 608-> 600B, -8B
  • Nhóm một số bài tập
  • Điều kiện đảo ngược Sđể giảm dấu ngoặc đơn
• 600-> 599B, ​​-1B
  • Thay đổi u/2trong dòng cuối cùng thứ ba của định nghĩa của Dđể u>>1, tiết kiệm một byte từ nén nó vào một nhân vật có khác >>1s.