Faça o maior infinito possível!

31

cantor forma normal

O sistema numérico ordinal é um sistema com números infinitos. Muitos números infinitos. Tantos números infinitos que literalmente não tem um infinito para representar sua própria infinitude. A imagem acima fornece uma pequena idéia de como eles funcionam. Um número ordinal ( construção de Von Neumann ) é um conjunto de ordinais anteriores. Por exemplo, 0 é o conjunto vazio, 1 é o conjunto {0}, 2 é o conjunto {0, 1} e etc. Então chegamos a ω, que é {0, 1, 2, 3 ...}. ω + 1 é {0, 1, 2, 3 ... ω}, ω duas vezes é {0, 1, 2 ... ω, ω + 1, ω + 2 ...} e você continua assim aquele.

Seu programa produzirá um conjunto de ordinais, como {0, 1, 4}. Sua pontuação será o menos ordinal mais do que o ordinal do seu conjunto. Para {0, 1, 4} a pontuação seria 5. Para {0, 1, 2 ...}, a pontuação seria ω.

Como você produz seus ordinais, você pergunta. Código de curso. Ou seja, seu programa produzirá uma lista potencialmente infinita de outros programas, entre aspas, um em cada linha (use a string literal "\ n" para representar novas linhas). Um programa corresponde à sua pontuação, conforme indicado acima. Por exemplo, se você gerar

"A"
"B"
"C"

onde A, B e C são respostas válidas e têm pontuações {0, 1, 4}, a pontuação do seu programa seria 5. Observe que A, B e C devem ser programas completos, não fragmentos.

Com base nas regras acima, um programa que não produz nada tem uma pontuação de 0 (o menos ordinal maior que todos {} é 0). Além disso, lembre-se de que um conjunto não pode se conter, através do axioma da fundação . Ou seja, todo conjunto (e, portanto, ordinal) tem um caminho até zero. Isso significa que um quine completo seria inválido, pois não é um conjunto.

Além disso, nenhum programa tem permissão para acessar recursos externos (seu próprio arquivo, a internet etc ...). Além disso, quando você listar sua partitura, coloque a forma normal do cantor ao lado dela, se ela ainda não estiver na forma normal do cantor, se você puder (se não, outra pessoa pode).

Depois de levar tudo em consideração, a resposta real que você postar deve ser inferior a 1.000.000 bytes (sem contar os comentários). (Esse limite superior provavelmente só entrará em ação no código gerado automaticamente). Além disso, você aumenta sua pontuação para cada byte que não usa (já que estamos lidando com infinitos, isso provavelmente só será considerado quando os ordinais estiverem muito próximos ou iguais). Novamente, este parágrafo se aplica apenas à resposta postada, não às geradas, ou às geradas, e assim por diante.

Isso possui a tag quine, porque pode ser útil gerar pelo menos parte do código do próprio código-fonte, para uso na criação de ordinais grandes. Porém, isso não é necessário (por exemplo, um envio com pontuação 5 provavelmente não precisaria de seu próprio código-fonte).

Para um exemplo elaborado e anotado, veja aqui .

PyRulez
fonte
Isso significa que não deve terminar para gerar um número infinito de cardeais? E onde está a parte de fonte restrita? Acho que essa tag não é para limitações de tamanho de código. Exigir as linhas de citação e as novas linhas convertidas em \ n parecia redundante para mim, outros formatos de lista internos deveriam ser permitidos?
precisa saber é o seguinte
@ user23013 Pode, a seu critério, nunca terminar para gerar um número infinito de ordinais. Embora citar e escapar de novas linhas seja redundante, muitos idiomas criaram recursos para essa tarefa. O que você quer dizer com outros formatos de lista?
PyRulez
Eu quis dizer qualquer formato de lista ou matriz reconhecível pelo idioma usado. Ou apenas torne a conversão \ n opcional. Uma solução rápida em muitos idiomas é simplesmente não usar nenhuma nova linha.
precisa saber é o seguinte
3
A imagem está quebrada. O que significa " conjunto não pode " significa? " a resposta real que você postar deve ter menos de 1.000.000 bytes " é muito mais fraca que o limite real, porque o StackExchange não permitirá uma resposta com mais de 30000 caracteres.
Peter Taylor
1
@NateEldredge Com palavras diferentes, prove que um ordinal computável deve ser contável.
Simply Beautiful Art

Respostas:

20

Haskell: ψ (Ω Ω ω ) + 999672 pontos

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 com ordinal ψ (Ω Ω ω ) + 1. Usa uma representação em árvore de ordinais descobertos por Jervell (2005) . A árvore com filhos α , β ,…, γ é denotada α :@ (β :@ (… :@ (γ :@ Z)…)). Essa ordem da esquerda para a direita concorda com Jervell, embora observe que Madore a vira da direita para a esquerda.

Haskell: Γ 0 + 999777 pontos

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 com ordinal Γ 0 + 1. Isso é baseado em uma generalização do Worm de Beklemishev para elementos com valor ordinal, que são representados recursivamente por worms.

Haskell: ε 0 + 999853 pontos

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 com ordinal ε 0 + 1. Isso é baseado no Worm de Beklemishev . A lista

map(+1 ++ [0] ++ map(+1 ++ [0] ++  ++ [0] ++ map(+1

representa o ordinal (ω y + ⋯ + ω p + ω ct ) - 1. Assim, as saídas de segundo nível [0], [1], [2], [3], ... representam 1, ω, ω ω , ω ω ω , ..., a saída do primeiro nível representa ε 0 e o programa inicial representa ε 0 + 1.

Haskell: ε 0 + 999807 pontos

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 com ordinal ε 0 + 1.

Zrepresenta 0, e podemos provar por indução transfinita em α , depois em β , que α :@ β≥ ω α + β . Portanto, existem saídas de segundo nível pelo menos tão grandes quanto qualquer torre ω ω ω , o que significa que a saída de primeiro nível é pelo menos ε 0 e o programa inicial é pelo menos ε 0 + 1.

Anders Kaseorg
fonte
2
Boa resposta. Você acha que poderia explicar mais? Gosto da sua ideia de usar um tipo bem ordenado.
precisa saber é o seguinte
1
Especificamente, quais ordinais ela está produzindo como saída?
PyRulez
Além disso, você conhece a forma normal do Cantor desses ordinais?
PyRulez
A forma normal do @PyRulez Cantor não é útil para descrever esses ordinais. ψ (Ω ^ Ω ^ ω), Γ₀ e ε₀ são todos números épsilon , portanto, embora possamos escrever equações circulares inutilmente semelhantes para sua forma normal de Cantor de “nível único” (ψ (Ω ^ Ω ^ ω) = ω ^ ψ (Ω ^ Ω ^ ω), Γ₀ = ω ^ Γ₀, ε₀ = ω ^ ε₀), não podemos escrevê-los como expressões em que cada expoente está recursivamente na forma normal do Cantor.
Anders Kaseorg
1
Por isso, você deve usar uma forma normal semelhante a Veblen para funções ordinais de recolhimento: p. Como tal, você escreveria Γ₀ = ψ (Ω ^ Ω) e ε₀ = ψ (0).
Simply Beautiful Art
5

Ruby, ψ 0X (ψ M + 1M + 1 Ω M + 1 )) (0)) + 999663 pontos

Supondo que eu entenda meu programa corretamente, minha pontuação é ψ 0X (ψ M + 1M + 1 Ω M + 1 )) (0)) + 999663 pontos em que ψ é uma função ordinal em colapso, X é o chi (função de colapso do Mahlo) e M é o primeiro 'ordinal' do Mahlo.

Este programa é uma extensão do que eu escrevi no Golf um número maior que o TREE (3) e supera totalmente todas as outras soluções aqui por enquanto.

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]}\""}

Experimente online!

Ruby, ψ 0I (I I )) + 999674 pontos

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]}\")")}

Experimente online! (aviso: não fará muito, pois claramente (0..1.0/0).map{...}não pode terminar. É assim que eu imprimo infinitamente muitos programas também.)

Ruby, ψ 0I (0)) + 999697 pontos

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]}\")")}

Experimente online!

Um programa de teste mais razoável que implementa (0..5).map{...}:

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]}\")")}

Experimente online!

Infelizmente, mesmo com (1..1).map{...}, você encontrará este programa extremamente intensivo em memória. Quero dizer, o comprimento da saída excede coisas como SCG (13).

Usando o programa mais simples, podemos considerar alguns 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]}\")")

Experimente online!

Basicamente, imprime o mesmo programa repetidamente, no formato de:

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

onde os xregistros inicializados estão relacionados ao ordinal ao programa e "..."mantêm os programas após a xredução. Se x==0, então, imprime

p

que é um programa que imprime nada com pontuação zero, portanto

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

tem uma pontuação de 1 e

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

tem uma pontuação de 2 e

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

tem uma pontuação de 3, etc., e meu programa original imprime esses programas no formato

puts("...")

onde ...estão os programas listados acima.

Meu programa atual realmente imprime esses programas no formato

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

Infinitamente, muitas vezes, e para valores como ω, ele faz algo semelhante a

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

E assim, a pontuação do programa

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

é 1+some_ordinale a pontuação de

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

é 1+some_ordinal+1e a pontuação 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]}\")")

é 1+some_ordinal+2.


Explicação dos ordinais:

f[a,n,b]reduz um ordinal a.

Todo número natural se reduz ao número natural abaixo dele.

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

[c,0,e]é o sucessor de c, e sempre se reduz a c.

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

[c,d,e] é uma hiperoperação associativa para trás, reduz-se da seguinte forma:

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] é o primeiro ordinal infinito (equivalente a ω) e reduz da seguinte forma:

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

[c] é o césimo ordinal ômega e reduz da seguinte forma:

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]é ψ d (c) e reduz o seguinte:

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]é basicamente o mesmo que [c,d,e], exceto que enumera a operação em [c]vez da operação sucessora.

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]
Arte simplesmente bonita
fonte
De acordo com a Googology wikia, eu sou o primeiro cardeal inacessível, nem o primeiro ordinal inacessível.
PyRulez
@PyRulez Sim, embora faça mais sentido ter um ordinal aqui do que um cardeal. Normalmente, diz-se que Ié o ordinal que se relaciona com o primeiro cardeal inacessível, assim como ω se refere a aleph null.
Simply Beautiful Art
4

Java + Brainf ***, ω + 999180 pontos

Um programa java que produz infinitos programas Brainf ***, dos quais cada um produz o último como saída.

Por quê? Porque eu posso.

Quaisquer melhorias na parte da geração Brainf *** são definitivamente bem-vindas.

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
fonte
1
Para seu gosto, é claro, mas o uso do nome real facilita a pesquisa. :)
luser droog
1
@luserdroog Não é verdade. Como tenho certeza de que você sabe incluir vários termos de pesquisa, é de igual dificuldade procurar programas BF com nomes diferentes.
Mbomb007
@ mbomb007 você está sugerindo que digitar "brainfuck | brainf * ck | brainfcuk | brainf ** k | brainf *** | brain **** | brainfu * k | ..." tem igual dificuldade em digitar "brainfuck"?
Sparr
O @Sparr StackExchange usa *como caractere curinga; basta digitar brainf***, ou brainf. Todas essas variações aparecem nos resultados da pesquisa. codegolf.stackexchange.com/help/searching
mbomb007
@ mbomb007 obrigado, eu não sabia que
Sparr
4

Haskell alfabetizado (GHC 7.10): ω² + 999686 pontos.

Isso servirá como exemplo de resposta. Desde que é um exemplo, só faz sentido usar a programação alfabetizada . Não vai marcar bem embora. Os passarinhos diminuirão minha pontuação, mas tudo bem. Primeiro, vamos fazer uma função auxiliar s. Se x é um ordinal, sx = x + 1, mas encontramos usos inesperados de s.

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

Felizmente, a função show faz toda a limpeza das cordas para nós. Também vale a pena fazer 0. Zero não é o sucessor de nada, mas s "" será igual a "main = putStrLn" "", que é igual a 0.

> z=s""

Agora criaremos uma função que recebe n e retorna ω * n.

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

Funciona criando ω * n por {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...}. O que é isso q? Por que, é a razão pela qual temos uma tag . q são as funções auxiliares acima até agora.

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

Observe que somente nas necessidades q, nenhum de seus sucessores (s (o (n)), s (s (o (n)))), pois eles não precisam das funções auxiliares (exceto indiretamente de on). Agora, temos apenas que produzir todos os ω * n para n finito.

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

Aqui vamos nós. ω ^ 2 Tendo usado apenas 314 caracteres de código, reivindico um bônus final de 999686, dando-me uma pontuação final de ω ^ 2 + 999686, que já está na forma normal de cantor.

Primeiras quatro linhas de saída (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
fonte
Agora vá escrever uma solução séria :-)
Simply Beautiful Art
2

GolfScript, ε₀ + 1 + 999537 pontos

{{
{"{"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~

Provavelmente pode ser melhor, mas fiquei com preguiça de depurar e provar ordinais maiores.

Ordinais menores

#ω^ω^ω
#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
fonte
1

Javascript (Nashorn), ω2 + 999807 pontos

Nashorn é o mecanismo Javascript incorporado ao Java. Isso também pode funcionar no Rhino, mas ainda não o testei.

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
fonte
É 2ω ou ω²?
kamoroso94
@ kamoroso94 FYI 2ω = ω.
Simply Beautiful Art
Ok, 2, meu mal.
kamoroso94