¡Crea el infinito más grande que puedas!

31

forma normal de cantor

El sistema de números ordinales es un sistema con números infinitos. Muchos números infinitos. Tantos números infinitos que literalmente no tiene un infinito para representar su propia infinitud. La imagen de arriba da una pequeña idea de cómo funcionan. Un número ordinal ( construcción de von Neumann ) es un conjunto de ordinales anteriores. Por ejemplo, 0 es el conjunto vacío, 1 es el conjunto {0}, 2 es el conjunto {0, 1} y etc. Luego llegamos a ω, que es {0, 1, 2, 3 ...}. ω + 1 es {0, 1, 2, 3 ... ω}, ω multiplicado por dos es {0, 1, 2 ... ω, ω + 1, ω + 2 ...} y sigues como ese.

Su programa generará un conjunto de ordinales, como {0, 1, 4}. Su puntaje será el menos ordinal más que todo el ordinal en su conjunto. Para {0, 1, 4} la puntuación sería 5. Para {0, 1, 2 ...}, la puntuación sería ω.

¿Cómo sacas tus ordinales que preguntas? Código por supuesto. Es decir, su programa generará una lista potencialmente infinita de otros programas, entre comillas, uno en cada línea (use la cadena literal "\ n" para representar nuevas líneas). Un programa corresponde a su puntaje como se indicó anteriormente. Por ejemplo, si saca

"A"
"B"
"C"

donde A, B y C son respuestas válidas y tienen puntajes {0, 1, 4}, el puntaje de su programa sería 5. Tenga en cuenta que A, B y C deben ser programas completos, no fragmentos.

Según las reglas anteriores, un programa que no genera nada tiene una puntuación de 0 (el menor ordinal mayor que todos {} es 0). Además, recuerde que un conjunto no puede contenerse, a través del axioma de la fundación . Es decir, cada conjunto (y, por lo tanto, ordinal) tiene una ruta de acceso a cero. Esto significa que un quine completo sería inválido ya que no es un conjunto.

Además, ningún programa puede acceder a recursos externos (su propio archivo, Internet, etc.). Además, cuando enumere su puntaje, coloque la forma normal de puntaje junto a él si aún no está en forma normal, si puede (si no, alguien más puede).

Después de tener en cuenta todo lo anterior, la respuesta real que publique debe ser inferior a 1,000,000 bytes (sin contar los comentarios). (Este límite superior probablemente solo entrará en juego para el código generado automáticamente). Además, puede aumentar su puntaje por cada byte que no use (dado que estamos tratando con infinitos, esto probablemente solo se tendrá en cuenta cuando los ordinales estén muy cerca o lo mismo). Una vez más, este párrafo solo se aplica a la respuesta publicada, no a las generadas, o las que generan, y así sucesivamente.

Esto tiene la etiqueta quine, porque puede ser útil generar al menos parte del código propio de las fuentes, para usar en la creación de ordinales grandes. Sin embargo, de ninguna manera es obligatorio (por ejemplo, un envío con puntaje 5 probablemente no necesitaría su propio código fuente).

Para un ejemplo resuelto y anotado, vea aquí .

code-challenge math quine code-generation PyRulez
fuente
¿Significa que no debería terminar para generar un número infinito de cardenales? ¿Y dónde está la parte de fuente restringida? Creo que esta etiqueta no es por limitaciones de longitud de código. Requerir tanto las citas citadas como las nuevas líneas convertidas a \ n me parecía redundante, ¿deberían permitirse otros formatos de lista incorporados?
jimmy23013
@ user23013 Puede, a su elección, nunca terminar para generar un número infinito de ordinales. Aunque citar y escapar de las nuevas líneas es redundante, muchos idiomas han incorporado instalaciones para esa tarea. ¿Qué quieres decir con otros formatos de lista?
PyRulez
Me refería a cualquier lista o formato de matriz reconocible por el idioma utilizado. O simplemente haga que la conversión \ n sea opcional. Sin embargo, una solución rápida en muchos idiomas es simplemente no usar líneas nuevas.
jimmy23013
3
La imagen está rota. ¿Qué significa " set can can it "? " la respuesta real que publique debe ser inferior a 1,000,000 bytes " es mucho más débil que el límite real, porque StackExchange no permitirá una respuesta de más de 30000 caracteres.
Peter Taylor
1
@NateEldredge Dicho de otra manera, pruebe que un ordinal computable debe ser contable.
Simplemente hermoso arte

Respuestas:

20

Haskell: ψ (Ω Ω ω ) + 999672 puntos

main=print$f++shows f"$iterate(Z:@)Z";f="data N=Z|N:@N deriving Show;r=repeat;s Z=[];s(a:@Z)=r a;s(Z:@b)=($u b)<$>h b;s(a:@b)=do(f,c)<-h b`zip`s a;f<$>[c:@b,a]\nh=scanl(flip(.))id.t;t(Z:@Z)=r(:@Z);t(Z:@b)=((Z:@).)<$>t b;t(a:@b)=flip(:@).(:@b)<$>s a;u Z=Z;u(Z:@b)=u b;u(a:@_)=a;g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

329 bytes de código con ordinal ψ (Ω Ω ω ) + 1. Utiliza una representación en árbol de ordinales descubiertos por Jervell (2005) . El árbol con hijos α , β , ..., γ se denota α :@ (β :@ (… :@ (γ :@ Z)…)). Este orden de izquierda a derecha está de acuerdo con Jervell, aunque tenga en cuenta que Madore lo cambia de derecha a izquierda.

Haskell: Γ 0 + 999777 puntos

main=print$f++shows f"$iterate((:[]).T)[]";f="data T=T[T]deriving(Eq,Ord,Show);r=reverse;s[]=[];s(T b:c)=(++c)<$>scanl(++)[](b>>cycle[fst(span(>=T b)c)++[T$r d]|d<-s$r b]);g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

224 bytes de código con ordinal Γ 0 + 1. Esto se basa en una generalización del gusano de Beklemishev a elementos de valor ordinal, que son representados recursivamente por gusanos.

Haskell: ε 0 + 999853 puntos

main=print$f++shows f"$map(:[])[0..]";f="s[]=[];s(0:a)=[a];s(a:b)=b:s(a:fst(span(>=a)b)++a-1:b);g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

148 bytes de código con ordinal ε 0 + 1. Esto se basa en el gusano de Beklemishev . La lista

map(+1)α ++ [0] ++ map(+1)β ++ [0] ++ ⋯ ++ [0] ++ map(+1)γ

representa el ordinal (ω gamma + ⋯ + ω ß + ω alpha ) - 1. Por lo tanto las salidas de segundo nivel [0], [1], [2], [3], ... representan 1, ω, ω ω , ω ω ω , ..., la salida del primer nivel representa ε 0 , y el programa inicial representa ε 0 + 1.

Haskell: ε 0 + 999807 puntos

main=print$f++shows f"$iterate(:@Z)Z";f="data N=Z|N:@N deriving Show;s Z=[];s(Z:@b)=repeat b;s(a:@Z)=scanl(flip(:@))Z$s a;s(a:@b)=(a:@)<$>s b;g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

194 bytes de código con ordinal ε 0 + 1.

Zrepresenta 0, y podemos demostrar por inducción transfinita en α , luego en β , que α :@ β≥ ω α + β . Así que hay salidas de segundo nivel al menos tan grande como cualquier torre omega omega ⋰ omega , que significa que la salida de primer nivel es al menos ε 0 y el programa inicial es al menos ε 0 + 1.

Anders Kaseorg
fuente
2
Buena respuesta. ¿Crees que podrías explicarlo más? Me gusta tu idea de usar un tipo bien ordenado.
PyRulez
1
Específicamente, ¿qué ordinales está produciendo como salida?
PyRulez
Además, ¿conoces la forma normal de estos ordinales de Cantor?
PyRulez
La forma normal de @PyRulez Cantor no es útil para describir estos ordinales. ψ (Ω ^ Ω ^ ω), Γ₀ y ε₀ son todos números épsilon , por lo tanto, si bien podemos escribir ecuaciones circulares inútiles similares para su forma normal de Cantor de "nivel único" (ψ (Ω ^ Ω ^ ω) = ω ^ ψ (Ω ^ Ω ^ ω), Γ₀ = ω ^ Γ₀, ε₀ = ω ^ ε₀), no podemos escribirlos como expresiones donde cada exponente esté recursivamente en la forma normal de Cantor.
Anders Kaseorg
1
Por lo tanto, debe usar una forma normal similar a Veblen para las funciones de colapso ordinal: p. Como tal, escribiría Γ₀ = ψ (Ω ^ Ω) y ε₀ = ψ (0).
Simplemente hermoso arte
5

Rubí, ψ 0 (ψ X (ψ M + 1 (Ω M + 1 Ω M + 1 )) (0)) + 999663 puntos

Suponiendo que entiendo mi programa correctamente, mi puntaje es ψ 0 (ψ X (ψ M + 1 (Ω M + 1 Ω M + 1 )) (0)) + 999663 puntos donde ψ es una función de colapso ordinal, X es el chi función (función de colapso de Mahlo), y M es el primer 'ordinal' de Mahlo.

Este programa es una extensión de la que escribí en Golf, un número mayor que TREE (3) y supera por completo a todas las otras soluciones aquí por ahora.

z=->x,k{f=->a,n,b=a,q=n{c,d,e=a;!c ?q:a==c ?a-1:e==0||e&&d==0?c:e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:n<1?9:!d ?[f[b,n-1],c]:c==0?n:[t=[f[c,n],d],n,d==0?n:[f[d,n,b,t]]]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+";"};y)};h=-1;(0..1.0/0).map{|i|puts "puts \"#{z[[i,h=[h,h,h]],1]}\""}

Pruébalo en línea!

Rubí, ψ 0 (ψ I (I I )) + 999674 puntos

z=->x,k{f=->a,n,b=a{c,d,e,q=a;a==c ?a-1:e==0||d==0?(q ?[c]:c):e ?[[c,d,f[e,n,b],q],f[d,n,b],c,q]:[n<1?9:d&&c==0?[d]:d ?[f[c,n],d]:[f[b,n-1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..1.0/0).map{|i|puts("puts(\"#{z[h=[h,h,h,0],1]}\")")}

Pruébalo en línea! (advertencia: no hará mucho, ya que claramente (0..1.0/0).map{...}no puede terminar. Es así como también imprimo infinitos programas).

Rubí, ψ 0 (ψ I (0)) + 999697 puntos

z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..1.0/0).map{|i|h=[h];puts|i|puts("puts(\"#{z[hz[h=[h],1]}\")")}

Pruébalo en línea!

Un programa de prueba más razonable que implementa en su (0..5).map{...}lugar:

z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..5).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..5).map{|i|h=[h];puts("puts(\"#{z[h,1]}\")")}

Pruébalo en línea!

Desafortunadamente, incluso con (1..1).map{...}, encontrará que este programa requiere mucha memoria. Quiero decir, la longitud de la salida excede cosas como SCG (13).

Al usar el programa más simple, podemos considerar algunos valores:

a = value you want to enter in.
z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="x=#{f[x,k]};puts(x==0??p:"+w+"#{z[f[x,k],k*2+1]}"+w+");";y)};puts("puts(\"#{z[a,1]}\")")

Pruébalo en línea!

Básicamente imprime el mismo programa repetidamente, en el formato de:

x=...;puts(x==0??p:"...");

donde el inicializado xregistra el ordinal con el que se relaciona el programa, y ​​la "..."retención de los programas después de que xse ha reducido. Si x==0, entonces imprime

p

que es un programa que no imprime nada con una puntuación de cero, por lo tanto

x=0;puts(x==0??p:"p");

tiene una puntuación de 1 y

x=1;puts(x==0??p:"x=0;puts(x==0??p:\"p\");");

tiene una puntuación de 2 y

x=2;puts(x==0??p:"x=1;puts(x==0??p:\"x=0;puts(x==0??p:\\\"p\\\");\");");

tiene un puntaje de 3, etc., y mi programa original imprime estos programas en el formato

puts("...")

¿Dónde ...están los programas mencionados anteriormente?

Mi programa actual realmente imprime estos programas en el formato

x=0;puts(x==0??p:"p;p;p;p;p;...");

Infinitamente muchas veces, y para valores como ω, hace algo similar a

x=ω;puts(x==0??p:"(x=0 program); (x=1 program); (x=2 program); ...")

Y así, el puntaje del programa

x=(some_ordinal);puts(x==0??p:"...")

es 1+some_ordinal, y la puntuación de

puts("x=(some_ordinal);puts(x==0??p:\"...\")")

es 1+some_ordinal+1, y la puntuación de

z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};puts("puts(\"#{z[some_ordinal,1]}\")")

es 1+some_ordinal+2.

Explicación de ordinales:

f[a,n,b]Reduce un ordinal a.

Cada número natural se reduce al número natural debajo de él.

f[k,n,b] = k-1

[c,0,e]es el sucesor de c, y siempre se reduce a c.

f[[c,0,e],n,b] = c

[c,d,e] Es una hiperoperación asociativa hacia atrás, se reduce de la siguiente manera:

f[[c,d,0],n,b] = c
f[[c,d,e],n,b] = [[c,d,f[e,n,b]],f[d,n,b],c]

[0] es el primer ordinal infinito (equivalente a ω) y se reduce de la siguiente manera:

f[[0],0,b] = [9,0,0]
f[[0],n,b] = [n,n,n]

[c] es el cth omega ordinal y se reduce de la siguiente manera:

f[[c],0,b] = [9,0,0]
f[[c],n,b] = [[f[b,n-1,b],f[c,n,b]],n,n]
Note the two-argument array here.

[c,d]es ψ d (c) y se reduce de la siguiente manera:

f[[c,d],0,b] = [9,0,0]
f[[0,d],n,b] = [[d],n,n]
f[[c,d],n,b] = [[f[c,n,c],d],n,n]

[c,d,e,0]es básicamente lo mismo que [c,d,e], excepto que enumera la operación en [c]lugar de la operación sucesora.

f[[c,0,e,0],n,b] = [c]
f[[c,d,0,0],n,b] = [c]
f[[c,d,e,0],n,b] = [[c,d,f[e,n,b],0],f[d,n,b],c,0]
Simplemente hermoso arte
fuente
Según la wikia de Googology, I es el primer cardenal inaccesible, ni el primer ordinal inaccesible.
PyRulez
@PyRulez Sí, aunque tiene más sentido tener un ordinal aquí en lugar de un cardenal. Por lo general, uno dice que Ies el ordinal que se relaciona con el primer cardenal inaccesible, así como ω se relaciona con aleph null.
Simplemente hermoso arte
4

Java + Brainf ***, ω + 999180 puntos

Un programa de Java que produce infinitos programas Brainf ***, cada uno de los cuales produce el último como salida.

¿Por qué? Porque puedo.

Cualquier mejora en la parte de generación Brainf *** es definitivamente bienvenida.

import java.io.*;import java.util.*;import static java.lang.System.*;
class O{
    static String F(String s){
        String t="++++++++++++++++++++";
        List<Character> c=Arrays.asList('+','-','.','<','>','[',']');
        t+="[->++>++>++>+++>+++>++++>++++<<<<<<<]>+++>+++++>++++++>>++>+++++++++++>+++++++++++++";
        for(int x=0,i=6;x<s.length();x++){
            int d=c.indexOf(s.charAt(x)),k=d;
            while(d>i){d--;t+=">";}
            while(d<i){d++;t+="<";}
            t+=".";i=k;
        }return t;
    };
    static void p(String a){
        int i=48;while(i<a.length()){out.println(a.substring(i-48,i));i+=48;}
        out.println(a.substring(i-48));out.println();
    }
    public static void main(String[]a) throws Exception{setOut(new PrintStream("o.txt"));String b="";while(true)p(b=F(b));}
}
SuperJedi224
fuente
1
A su gusto, por supuesto, pero usar el nombre real facilita la búsqueda. :)
luser droog
1
@luserdroog No es cierto. Como estoy seguro de que sabe cómo incluir múltiples términos de búsqueda, es de igual dificultad buscar programas BF con diferentes nombres.
mbomb007
@ mbomb007 ¿sugiere que escribir "brainfuck | brainf * ck | brainfcuk | brainf ** k | brainf *** | brain **** | brainfu * k | ..." es igual de difícil que escribir "brainfuck"?
Sparr
@Sparr StackExchange utiliza *como carácter comodín, por lo que sólo tiene que escribir brainf***, o brainf. Todas esas variaciones aparecen en los resultados de búsqueda. codegolf.stackexchange.com/help/searching
mbomb007
@ mbomb007 gracias, no lo sabía
Sparr
4

Alfabetizado Haskell (GHC 7.10): ω² + 999686 puntos.

Esto servirá como una respuesta de ejemplo. Como es un ejemplo, solo tiene sentido usar programación alfabetizada . Sin embargo, no puntuará bien Los pajaritos disminuirán mi puntaje, pero bueno. Primero, hagamos una función auxiliar s. Si x es un ordinal, sx = x + 1, pero encontramos usos inesperados de s.

> s x="main=putStrLn "++show x

La función show afortunadamente hace toda la desinfección de cadenas por nosotros. También vale la pena hacer 0. Zero no es el sucesor de nada, pero s "" será igual a "main = putStrLn" "", que es igual a 0.

> z=s""

Ahora haremos una función que tome n y devuelva ω * n.

> o 0=z
> o n=q++"\nmain=putStrLn$unlines$map show$iterate s$o "++show(n-1)

Funciona haciendo ω * n por {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...}. ¿Qué es esto q? Por qué, es la razón por la que tenemos una etiqueta quine . q son las funciones de ayuda anteriores hasta ahora.

> h x = x ++ show x
> q = h "s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h "

Tenga en cuenta que solo en las necesidades q, no en ninguno de sus sucesores (s (o (n)), s (s (o (n)))), ya que no necesitan las funciones auxiliares (excepto indirectamente de o n). Ahora solo tenemos que generar todos ω * n para n finito.

> main=mapM(print.o)[0..]

Aquí vamos. 2 ^ 2 Habiendo usado solo el código 314, reclamo un bono final de 999686, lo que me da un puntaje final de ω ^ 2 + 999686, que ya está en la forma normal de cantor.

Primeras cuatro líneas de salida (0, ω, ω * 2, ω * 3):

"main=putStrLn \"\""
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 0"
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 1"
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 2"
PyRulez
fuente
Ahora ve a escribir una solución seria :-)
Simply Beautiful Art
2

GolfScript, ε₀ + 1 + 999537 puntos

{{
{"{"lib`+"}:lib~~"@++"~"+p}:output;
{{}}:nothing;
{{1{).2$`+output 1}do}}:list;
{{\.(`2$`+" iter"+@`if output}}:iter;
{{1${@`@(2$`{rep~}+++\}{;;}if~}}:rep;
{\`\+}:combine;
{{\@@~}}:swap;
{{1${1$(1$`{rangemap~}+[+@@[\\]]{~}/+}{;;}if}}:rangemap;
{`{}+}:wrap;
}}:lib~~
nothing {iter combine list~} {rep combine} {~swap combine combine} rep combine swap combine combine {~list~} combine rangemap {~~} combine combine swap combine combine swap combine combine list~

Probablemente puede ser mejor, pero me volví demasiado vago para depurar y probar ordinales más grandes.

Ordenales más pequeños

#ω^ω^ω
#nothing {iter combine list~} {rep combine swap combine combine list~} {rep combine swap combine combine swap combine combine list~} rep combine swap combine combine swap combine combine swap combine combine list~
#ω^ω^2
#nothing {iter combine list~} { {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~} rep combine swap combine combine swap combine combine list~
#ω^nω
#nothing {iter combine list~} 2 { {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~} rep~
#ω^ω
#nothing {iter combine list~} {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~
#ω^n
#nothing {iter combine list~} 3 {rep combine swap combine combine list~} rep~
#ω^3
#nothing {{iter combine list~} rep combine swap combine combine list~} rep combine swap combine combine list~
#ω^2
#nothing {iter combine list~} rep combine swap combine combine list~
#nω
#nothing 3 {iter combine list~} rep~
#2ω
#nothing iter combine list combine iter combine list~
#ω
#nothing iter combine list~
#finite
#2 nothing iter~
jimmy23013
fuente
1

Javascript (Nashorn), ω2 + 999807 puntos

Nashorn es el motor Javascript que viene integrado en Java. Esto también puede funcionar en Rhino, pero aún no lo he probado en eso.

c="(b=function(a){print(a?\"(b=\"+b+\")(\"+(a-1)+\")\":\"c=\\\"(b=function(a){print(a?'(b='+b+')'+'('+(a-1)+')':'')})(\\\";a=0;while(++a)print(c+a+\\\")\\\")\")})(";a=0;while(++a)print(c+a+")")
SuperJedi224
fuente
¿Es 2ω o ω²?
kamoroso94
@ kamoroso94 FYI 2ω = ω.
Simplemente hermoso arte
De acuerdo, ω • 2, mi mal.
kamoroso94