Im Anschluss an das kürzeste Abschlussprogramm, dessen Ausgabegröße Grahams Nummer und Golf eine Nummer über TREE (3) übersteigt, stelle ich eine neue Herausforderung dar.

Die Loader-Nummer ist eine sehr große Zahl, die schwer zu erklären ist (da sie selbst das Ergebnis einer Code-Golf-Übung mit einem flexiblen Ziel war). Es gibt eine Definition und Erklärung hier , aber für die Zwecke der Selbsthaltung, werde ich versuchen , es auch in diesem Beitrag später zu erklären.

Der verwendete Algorithmus Ralph Loader erzeugt eine der größten Zahlen aller (berechenbaren) Algorithmen, die jemals geschrieben wurden! In der Tat ist die Loader-Nummer die größte "berechenbare" Nummer im Googology Wiki. (Mit "berechenbarer" Zahl ist eine Zahl gemeint, die im Sinne einer Berechnung definiert wurde.) Das bedeutet, dass Sie hineingehen könnten , wenn die Antwort auf interessante Weise eine Zahl ergibt, die größer ist als die Nummer des Laders (dh nicht nur die Nummer des Laders + 1) Googologie-Geschichte! Davon abgesehen sind Programme, die so etwas wie Loaders Nummer + 1 produzieren, definitiv gültige Antworten und Anwärter auf diese Frage. erwarte einfach keinen Ruhm.

Ihre Aufgabe ist es, ein Abschlussprogramm zu erstellen, das eine Nummer erzeugt, die größer als die Nummer des Loaders ist. Das ist Code-Golf , also gewinnt das kürzeste Programm!

• Sie dürfen keine Eingaben machen.
• Ihr Programm muss schließlich deterministisch beendet werden, Sie können jedoch davon ausgehen, dass der Computer über unendlichen Speicher verfügt.
• Sie können davon ausgehen, dass der Zahlentyp Ihrer Sprache einen beliebigen endlichen Wert enthalten kann , müssen jedoch erläutern, wie dies in Ihrer Sprache genau funktioniert (Beispiel: Hat ein Gleitkomma eine unendliche Genauigkeit?)
  • Unendlichkeiten sind als Ausgabe nicht erlaubt.
  • Unterlauf eines Zahlentyps löst eine Ausnahme aus. Es wickelt sich nicht um.
• Sie müssen erklären, warum Ihre Nummer so groß ist, und eine unbenutzte Version Ihres Codes angeben, um zu überprüfen, ob Ihre Lösung gültig ist (da es keinen Computer mit genügend Speicher zum Speichern der Loader-Nummer gibt).

Hier ist eine Erklärung der Loader-Nummer. Weitere Informationen finden Sie unter http://googology.wikia.com/wiki/Loader%27s_number und den darin enthaltenen Links. Insbesondere enthält es ein Programm, das die Loader-Nummer exakt (per Definition) erzeugt.

Die Konstruktionsrechnung ist im Wesentlichen eine Programmiersprache mit ganz bestimmten Eigenschaften.

Zunächst wird jedes syntaktisch gültige Programm beendet. Es gibt keine Endlosschleifen. Dies ist sehr nützlich, da es bedeutet, dass unser Programm nicht hängen bleibt, wenn wir ein beliebiges Konstruktionskalkülprogramm ausführen. Das Problem ist, dass dies impliziert, dass die Berechnung der Konstruktionen nicht vollständig ist.

Zweitens ist es unter den nicht-Turing-vollständigen Sprachen eine der mächtigsten. Wenn Sie nachweisen können, dass eine Turing-Maschine bei jeder Eingabe anhält, können Sie im Wesentlichen eine Funktion in der Konstruktionsrechnung programmieren, die diese simuliert. (Dies macht es nicht vollständig, weil es stoppende Maschinen gibt, von denen Sie nicht beweisen können, dass sie anhalten.)

Die Loader-Nummer ist im Wesentlichen eine beschäftigte Bibernummer für die Berechnung von Konstruktionen, die berechnet werden kann, da alle Coc-Programme enden.

Insbesondere definiert loader.c eine aufgerufene Funktion D. Durchläuft ungefähr D(x)alle Bitfolgen , die kleiner als sind x, interpretiert sie als Coc-Programme, führt die syntaktisch gültigen aus und verkettet die Ergebnisse (die auch Bitfolgen sein werden). Es gibt diese Verkettung zurück.

Die Nummer des Laders lautet D(D(D(D(D(99))))).

Eine besser lesbare Kopie des Codes aus dem Googolology-Wiki

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

Dies ist ein verschlüsselter Code.

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

Dekodierter Code:

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

Entschlüsselter, ungelöster Code (Bedingungen und Zeug werden von loader.c aufbewahrt):

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

Hierbei wird angenommen, dass:

• Unendlicher Aufrufstapel
• Unendliche Erinnerung
• Unendliche Präzision Number
• Unendliche Größe Number
• Bitshift- und bitweise Operatoren arbeiten mit unendlichen Bit-Ganzzahlen anstelle von 53 Bits. Die bitweise Negation negiert immer noch das Vorzeichenbit.

Kodierungs- / Dekodierungsalgorithmus:

Die Kodierung erfolgt wie folgt:

• Nehmen Sie eine wiederholte Zeichenfolge, nennen Sie es S.
• Ersetzen Sie alles S im Code durch einen Schlüssel K.
• Setzen Sie K und S am Ende.
• Erstellen Sie eine Liste mit Schlüsseln und setzen Sie einen Dekodierungsalgorithmus, damit der Code tatsächlich ausgeführt wird.

Der Dekodierungsalgorithmus:

• Liste der Schlüssel nehmen.
• Nimm den frühesten Schlüssel K.
• Teilen Sie die Zeichenfolge für jeden K.
• Da das letzte Array KS ersetzen soll, platzieren Sie es und ersetzen Sie alles K, indem Sie das Array mit dem aufgerufenen Wert S verbinden.

Die Komprimierung wurde mit diesem Code durchgeführt . Aktivieren Sie nur das letzte Kontrollkästchen. Da dies die größte Speicherung zuerst codiert, ist es nicht die effizienteste Komprimierung, aber ich weiß auch nicht, wie ich sie verkleinern soll.

JavaScript, (339 Zeichen )

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

Dieser Code nimmt die 16-Bit-Zeichenfolge als einen, konvertiert sie in eine 8-Bit-Zeichenfolge mit derselben Binärdatei (BE) und evales.

Der decodierte Code ist der obige codierte Code.

Beweis, dass D ^ 6 (9)> D ^ 5 (99)

Dazu würden wir D (9) und 99 vergleichen.

Wenn Sie den Code manuell ausführen, ist D (9) gleich (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))))))))))))))))))))))))))))))))und sogar D (0) ist gleich8646911284551352321 .

Also, D (9) >>> 99, und da D streng zunimmt, gilt D ^ 6 (9)> D ^ 5 (99).

• 508B-> 501B, -7B
  • -1B für ... Ich weiß nicht warum. Ich habe mich geändert D(D(D(D(D(99)))))zuD(D(D(D(D(D(9)))))) . Auch das mischte die Buchstaben.
  • -6B zur Wieder Zugabe &&(1)für D(x)Zustand s - Schleife.
• 501B-> 495B, -6B
  • Korrigiert die meisten /2s zu >>1s weilNumber
  • 6 Byte speichern von irgendwoher
  • Sie können meinen Versuch in diesem Update hier sehen
• 495-> 492B, -3B
  • Durch Ändern des Decoders von for...inauf for...of.
• 492-> 487B, -5B
  • Unnötige Zuordnungen entfernen
  • Ändern der Argumentnamen
• 487-> 485B, -2B
  • 1 Byte von der Verwendung evalfür das DEntfernen return.
  • 1-Byte-Komprimierung, bei der die schließenden Klammern zu einem Komma kombiniert werden.
• 485-> 481B, -4B
  • Durch Komprimieren verschiedener Teilzeichenfolgen.

Python 3, D ^ 6 (9) ( ₆₀₈ 600 Bytes)

_='r=a=0@EM:#y-~y<<x@I8Br=0.FC1+IN)#r@Gx):#xN>>I)@?t8BUtOr#A(V?IH).f==2CEf,EVS(v+2,6yOc,IHH.f<2Ct-(f>v)*c.f-vCy@A(M:#5<<EM.Gy)-1CQx,4,Z(rH@Jx8,aBf=d=c=0BWX7,14Bwhile 1:B.x:Jx-1)Y~F:breakKd,UGJxHOGrOGr)B.c-r:K.not(Gu)or(Gr)-fHR.F:XQd,4,rTA(Wd)K.fNR.[d,cT6t);X6u)B.c:B!.FR q=~u&2|FK .q:X1<<EGuOu)K  Wc=Eq and u,EGcOtH,rYu/2&[Wc);X6tT9Ba=EEWEu,Ex,cHOa)#a\nprint(JJJJJJ9HHH)Y\n!if !  x=xNK#Breturn . if 6Q13,-4,8):Bglobal r?S(v,y,c,@\ndef R:K! KB B\n C else EP([F:c=EFx%2Uf,x=GGL(V?GxH,H))IZ(xJD(My,x)N>>1O),QS(4,T);t=Wt,Xu='
for Y in 'XWTQONMJIHVGUF[ECBKR@?86.#!Y':_=_.split(Y);_=_.pop().join(_)
exec(_)

Dies ist ein verschlüsselter Code. Extrahiert:

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/2&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)))))))

Hierbei wird angenommen, dass:

• Unendlicher Aufrufstapel
• Unendliche Erinnerung

Dies ist im Grunde ein Port meiner JavaScript-Antwort . Weitere Informationen finden Sie in diesem Abschnitt.

Die Kompression wurde mit erledigt dies .

Ich kenne mich in Python nicht sehr gut aus, daher gibt es mit Sicherheit Stellen, an denen Bytes gespart werden können. Ich denke, dass Sub-600 möglich ist.

• 608-> 600B, -8B
  • Einige Zuordnungen gruppiert
  • Umgekehrte Bedingungen S, um Klammern zu reduzieren