Golf un número mayor que el número de Loader

18

Como seguimiento al programa de terminación más corto cuyo tamaño de salida excede el número de Graham y Golf un número mayor que TREE (3) , presento un nuevo desafío.

El número del cargador es un número muy grande, que es un poco difícil de explicar (ya que fue el resultado de un ejercicio de golf de código con un objetivo flexible). Hay una definición y explicación aquí , pero a los efectos de autocontención, que intentará explicar más adelante en este post también.

¡El algoritmo utilizado por Ralph Loader produce uno de los números más grandes de cualquier algoritmo (computable) jamás escrito! De hecho, el número de Loader es el número "computable" más grande en el Wiki de Googología. (Por número "computable", significan un número definido en términos de un cálculo). Eso significa que si la respuesta produce un número mayor que el número de Loader de una manera interesante (es decir, no solo el número de Loader + 1), podría bajar en Historia de la googología! Dicho esto, los programas que producen algo como el número + 1 de Loader son definitivamente respuestas válidas y contendientes a esta pregunta; Simplemente no esperes ninguna fama.

Su trabajo es crear un programa de terminación que produzca un número mayor que el número de Loader. Esto es , por lo que gana el programa más corto.

  • No está permitido tomar aportes.
  • Su programa finalmente debe terminar de manera determinista, pero puede suponer que la máquina tiene memoria infinita.
  • Puede suponer que el tipo de número de su idioma puede contener cualquier valor finito, pero necesita explicar cómo funciona exactamente en su idioma (por ejemplo: ¿un flotador tiene una precisión infinita?)
    • No se permiten infinitos como salida.
    • El flujo inferior de un tipo de número produce una excepción. No se envuelve.
  • Debe proporcionar una explicación de por qué su número es tan grande y una versión no codificada de su código para verificar si su solución es válida (ya que no hay una computadora con suficiente memoria para almacenar el número de Loader).

Así que aquí hay una explicación del número de Loader. Consulte http://googology.wikia.com/wiki/Loader%27s_number y los enlaces en él para obtener detalles más precisos. En particular, contiene un programa que produce el número de Loader exactamente (por definición).

El cálculo de las construcciones es esencialmente un lenguaje de programación con propiedades muy particulares.

En primer lugar, cada programa sintácticamente válido finaliza. No hay bucles infinitos. Esto será muy útil, porque significa que si ejecutamos un programa de cálculo de construcciones arbitrario, nuestro programa no se atascará. El problema es que esto implica que el cálculo de las construcciones no está completo.

En segundo lugar, entre los idiomas completos que no son de Turing, es uno de los más poderosos. Esencialmente, si puede probar que una máquina de Turing se detendrá en cada entrada, puede programar una función en el cálculo de construcciones que la simule. (Esto no hace que el proceso sea completo, porque hay máquinas de detención que no puede probar que se están deteniendo).

El número del cargador es esencialmente un número de castor ocupado para el cálculo de construcciones, que es posible calcular ya que todos los programas coc terminan.

En particular, loader.c define una función llamada D. Aproximadamente, D(x)itera sobre todas las cadenas de bits inferiores ax , las interpreta como programas coc, ejecuta las sintácticamente válidas y concatena los resultados (que también serán cadenas de bits). Devuelve esta concatenación.

El número del cargador es D(D(D(D(D(99))))).

Una copia más legible del código de la wiki de googolología

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)))));}
PyRulez
fuente
66
Aconsejaría que no se rechace esto por similitud con la pregunta TREE (3): el número del cargador es mucho mayor que el TREE (3) que se requieren enfoques nuevos e interesantes.
lirtosiast el
2
@ fəˈnɛtɪk Bueno, imprimir el número de Loader + 1 sigue siendo interesante desde una perspectiva de golf de código (por ejemplo, ¿puedes superar los 512 bytes originales?) También hay algunas generalizaciones naturales del número de cargador que podrían ser más fáciles de implementar (por ejemplo, usando ZFC en lugar de CoC). Además, se podrían usar secuencias de camarillas codiciosas o juegos de promesa finita.
PyRulez
2
Desafortunadamente, como no entiendo la construcción del número de Loader y no parece que se conozcan los límites superiores en términos de la jerarquía de rápido crecimiento, no puedo dar ninguna buena respuesta aquí. Creo que la mayoría de las respuestas serán extensiones del número de Loader o cosas como las secuencias de camarillas codiciosas y los juegos de promesa finita ...
Simply Beautiful Art
1
@SimplyBeautifulArt Oh, chico, si no lo entiendes, eso no es un buen augurio para este desafío. : PI podría intentar explicártelo con más detalle en el chat, pero tampoco conozco ningún límite superior de la jerarquía.
PyRulez
1
@SimplyBeautifulArt En particular, dado que la constante de Loader fue elegida específicamente para tratar de ser el número más grande generado por una cierta cantidad de código (donde como el número de Graham y TREE (3) en números matemáticamente interesantes que resultan ser grandes), creo que la mayoría de las respuestas solo serán el número de Loader + 1.
PyRulez

Respuestas:

9

JavaScript, D ^ 6 (9) ( 508 501 495 492 487 485 481 bytes)

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

Este es un código codificado.

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

Código decodificado:

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

Código descodificado y descodificado (las condiciones y las cosas se guardan de 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))))))

En esto, se supone que es:

  • Pila de llamadas infinitas
  • Memoria infinita
  • Precisión infinita Number
  • Magnitud infinita Number
  • Los operadores Bitshift y bitwise funcionan en enteros de bits infinitos en lugar de 53 bits. La negación bit a bit todavía niega el bit de signo.

Algoritmo de codificación / decodificación:

La codificación se realiza de la siguiente manera:

  • Tome una cadena repetida, llámela S.
  • Reemplace todas las S en el código por una clave K.
  • Pon K y S al final.
  • Haga una lista de claves y también coloque un algoritmo de decodificación para que el código realmente se ejecute.

El algoritmo de decodificación:

  • Toma la lista de llaves.
  • Tome la primera clave K.
  • Divide la cuerda para cada K.
  • Como lo último de la matriz es qué reemplazar KS, revíselo y reemplace todo K uniendo la matriz con el valor emergente S.

La compresión se realizó con este código , marque solo la última casilla. Como esto codificará el mayor ahorro primero, no es la compresión más eficiente, pero tampoco sé cómo hacerlo más pequeño.

JavaScript, (339 caracteres )

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

Este código tomará la cadena de 16 bits como a, la convertirá en una cadena de 8 bits con el mismo binario (BE) y la evalconvertirá.

El código decodificado es el código codificado anterior.

Prueba de que D ^ 6 (9)> D ^ 5 (99)

Para esto, compararíamos D (9) y 99.

Al ejecutar manualmente el código, D (9) se encuentra igual a (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)))))))))))))))))))))))))))))))), e incluso D (0) es igual a 8646911284551352321.

Entonces, D (9) >>> 99, y debido a que D está aumentando estrictamente, D ^ 6 (9)> D ^ 5 (99).

  • 508B-> 501B, -7B
    • -1B para ... No sé por qué. Me cambié D(D(D(D(D(99)))))a D(D(D(D(D(D(9)))))). También eso barajó las letras.
    • -6B para volver a agregar &&(1)para D(x)la condición del bucle.
  • 501B-> 495B, -6B
    • Se corrigió la mayoría de /2s a >>1s porqueNumber
    • 6 bytes guardados desde algún lugar
    • Puedes ver mi intento en esta actualización aquí
  • 495-> 492B, -3B
    • Al cambiar el decodificador de for...ina for...of.
  • 492-> 487B, -5B
    • Eliminar tareas innecesarias
    • Cambiar nombres de argumentos
  • 487-> 485B, -2B
    • 1 byte de usar evalpara D, eliminar return.
    • Compresión de 1 byte que combina los paréntesis de cierre con una coma.
  • 485-> 481B, -4B
    • Al comprimir diferentes subcadenas.
Naruyoko
fuente
O páselo fácilmente con la misma longitud reemplazando 99 con M9, lo que hace que el valor D ^ 6 (9).
Naruyoko
0

Python 3, D ^ 6 (9) ( 608 600 599 bytes)

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

Este es un código codificado. Extraído:

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

En esto, se supone que es:

  • Pila de llamadas infinitas
  • Memoria infinita

Esto es básicamente un puerto de mi respuesta de JavaScript . Para más detalles, verifique eso.

La compresión se hizo con esto .

No estoy muy bien informado en Python, por lo que ciertamente hay lugares para guardar bytes. Creo que sub-600 es posible. Sub-600 ha sido probado.

  • 608-> 600B, -8B
    • Agrupamos algunas tareas
    • Condiciones invertidas de Sreducir paréntesis
  • 600-> 599B, ​​-1B
    • Cambiando u/2en la tercera última línea de la definición de Da u>>1, salvando un byte de comprimirlo a un carácter con otro >>1s.
Naruyoko
fuente
0

Ruby, D ^ 6 (9) (553 bytes)

_='F=$a=0TEK#y-~yUx.Z@#F=x%2G1?0R1+Z(x/2).L@#x/2>>[email protected])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(_)

Este es un código codificado. Extraído:

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

Este código es el número del cargador con D 6 (9) en su lugar.

En esto, se supone que es:

  • Pila de llamadas infinitas
  • Memoria infinita

Esto es básicamente un puerto de mi respuesta de JavaScript y la respuesta de Python 3 . Para más detalles, verifíquelos.

La compresión se realizó con esto (puede aparecer ya que no existe).

Soy un principiante en Ruby, así que tal vez menos de 512 es posible, pero lo dudo.

Naruyoko
fuente