Faites le plus grand infini possible!

31

forme normale de cantor

Le système de nombres ordinaux est un système avec des nombres infinis. Beaucoup de nombres infinis. Tant de nombres infinis qu'il n'a littéralement pas d'infini pour représenter sa propre infinité. L'image ci-dessus donne une petite idée de leur fonctionnement. Un nombre ordinal ( construction de Von Neumann ) est un ensemble d'ordinaux précédents. Par exemple, 0 est l'ensemble vide, 1 est l'ensemble {0}, 2 est l'ensemble {0, 1} et etc. Ensuite, nous arrivons à ω, qui est {0, 1, 2, 3 ...}. ω + 1 est {0, 1, 2, 3 ... ω}, ω fois deux est {0, 1, 2 ... ω, ω + 1, ω + 2 ...} et vous continuez comme cette.

Votre programme affichera un ensemble d'ordinaux, tels que {0, 1, 4}. Votre score sera alors le moins ordinal plus que tous les ordinaux de votre set. Pour {0, 1, 4}, le score serait 5. Pour {0, 1, 2 ...}, le score serait ω.

Comment sortez-vous vos ordinaux que vous demandez. Code bien sûr. À savoir, votre programme affichera une liste potentiellement infinie d'autres programmes, entre guillemets, un sur chaque ligne (utilisez la chaîne littérale "\ n" pour représenter les nouvelles lignes). Un programme correspond à son score comme indiqué ci-dessus. Par exemple, si vous sortez

"A"
"B"
"C"

où A, B et C sont eux-mêmes des réponses valides et ont des scores {0, 1, 4}, le score de votre programme serait 5. Notez que A, B et C doivent être des programmes complets, pas des fragments.

Sur la base des règles ci-dessus, un programme qui ne produit rien a un score de 0 (le moins ordinal supérieur à tous {} est 0). Souvenez-vous également qu'un ensemble ne peut pas se contenir lui-même, via l' axiome de fondation . A savoir, chaque ensemble (et donc ordinal) a un chemin vers zéro. Cela signifie qu'un quine complet serait invalide car ce n'est pas un ensemble.

De plus, aucun programme n'est autorisé à accéder à des ressources externes (son propre fichier, Internet etc ...). De plus, lorsque vous listez votre score, mettez la forme normale du cantor à côté si elle n'est pas déjà sous la forme normale du cantor, si vous le pouvez (sinon, quelqu'un d'autre peut le faire).

Après avoir pris en compte tout ce qui précède, la réponse réelle que vous publiez doit être inférieure à 1 000 000 octets (sans compter les commentaires). (Cette limite supérieure n'entrera probablement en jeu que pour le code généré automatiquement). De plus, vous pouvez incrémenter votre score pour chaque octet que vous n'utilisez pas (car nous avons affaire à des infinis, cela ne sera probablement pris en compte que lorsque les ordinaux sont très proches ou identiques). Encore une fois, ce paragraphe s'applique uniquement à la réponse publiée, pas aux réponses générées, ni à celles générées par les réponses générées, etc.

Celui-ci a la balise quine, car il peut être utile de générer au moins une partie du code propre des sources, pour une utilisation dans la fabrication de grandes ordinales. Ce n'est en aucun cas requis (par exemple, une soumission avec un score de 5 n'aurait probablement pas besoin de son propre code source).

Pour un exemple élaboré et annoté, voir ici .

PyRulez
la source
Cela signifie-t-il qu'il ne doit pas se terminer pour produire un nombre infini de cardinaux? Et où est la partie à source restreinte? Je pense que cette balise n'est pas pour les limitations de longueur de code. Le fait de demander à la fois des devis et des sauts de ligne convertis en \ n me paraissait redondant. D'autres formats de liste intégrés devraient-ils être autorisés?
jimmy23013
@ user23013 Il peut, à votre gré, ne jamais se terminer pour produire un nombre infini d'ordinaux. Bien que la citation et l'échappement des sauts de ligne soient redondants, de nombreuses langues ont intégré des fonctionnalités pour cette tâche. Qu'entendez-vous par d'autres formats de liste?
PyRulez
Je voulais dire n'importe quel format de liste ou de tableau reconnaissable par la langue utilisée. Ou rendez simplement la conversion \ n facultative. Cependant, une solution rapide dans de nombreuses langues consiste à ne pas utiliser de nouvelles lignes.
jimmy23013
3
L'image est cassée. Que signifie " ensemble ne peut-il pas " signifier? « la réponse réelle que vous publiez doit être inférieure à 1 000 000 octets » est beaucoup plus faible que la limite réelle, car StackExchange n'autorise pas une réponse de plus de 30000 caractères.
Peter Taylor
1
@NateEldredge Formulé différemment, prouvez qu'un ordinal calculable doit être dénombrable.
Simply Beautiful Art

Réponses:

20

Haskell: ψ (Ω Ω ω ) + 999672 points

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 octets de code avec l'ordinal ψ (Ω Ω ω ) + 1. Utilise une représentation arborescente des ordinaux découverte par Jervell (2005) . L'arbre avec les enfants α , β ,…, γ est noté α :@ (β :@ (… :@ (γ :@ Z)…)). Cet ordre de gauche à droite est d'accord avec Jervell, bien que notez que Madore le retourne de droite à gauche.

Haskell: Γ 0 + 999777 points

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 octets de code avec l'ordinal Γ 0 + 1. Ceci est basé sur une généralisation du ver de Beklemishev aux éléments à valeur ordinale, qui sont eux-mêmes représentés récursivement par des vers.

Haskell: ε 0 + 999853 points

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 octets de code avec l'ordinal ε 0 + 1. Ceci est basé sur le ver de Beklemishev . La liste

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

représente l'ordinal (ω la y + ⋯ + ω la ß + ω alpha ) - 1. Donc , les sorties de second niveau [0], [1], [2], [3], ... représentent 1, ω, ω ω , ω ω ω , ..., la sortie de premier niveau représente ε 0 , et le programme initial représente ε 0 + 1.

Haskell: ε 0 + 999807 points

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 octets de code avec l'ordinal ε 0 + 1.

Zreprésente 0, et on peut prouver par induction transfinie sur α , puis sur β , que α :@ β≥ ω α + β . Il y a donc des sorties de deuxième niveau au moins aussi grandes que n'importe quelle tour ω ω ω , ce qui signifie que la sortie de premier niveau est au moins ε 0 et que le programme initial est au moins ε 0 + 1.

Anders Kaseorg
la source
2
Bonne réponse. Pensez-vous que vous pourriez l'expliquer davantage? J'aime votre idée d'utiliser un type bien ordonné.
PyRulez
1
Plus précisément, quels ordinaux produit-il en sortie?
PyRulez
Connaissez-vous également la forme normale du Cantor de ces ordinaux?
PyRulez
La forme normale de @PyRulez Cantor n'est pas utile pour décrire ces ordinaux. ψ (Ω ^ Ω ^ ω), Γ₀ et ε₀ sont tous des nombres epsilon , donc alors que nous pouvons écrire des équations circulaires inutilement similaires pour leur forme normale de Cantor à «un niveau» (ψ (Ω ^ Ω ^ ω) = ω ^ ψ) (Ω ^ Ω ^ ω), Γ₀ = ω ^ Γ₀, ε₀ = ω ^ ε₀), nous ne pouvons pas les écrire comme des expressions où chaque exposant est récursivement sous la forme normale de Cantor.
Anders Kaseorg
1
D'où la raison pour laquelle vous devriez utiliser une forme normale de type Veblen pour les fonctions d'effondrement ordinales: p. En tant que tel, vous écririez Γ₀ = ψ (Ω ^ Ω) et ε₀ = ψ (0).
Simply Beautiful Art
5

Rubis, ψ 0X (ψ M + 1M + 1 Ω M + 1 )) (0)) + 999663 points

En supposant que je comprends bien mon programme, mon score est ψ 0X (ψ M + 1M + 1 Ω M + 1 )) (0)) + 999663 points où ψ est une fonction de regroupement ordinale, X est le chi (fonction d'effondrement de Mahlo), et M est le premier «ordinal» de Mahlo.

Ce programme est une extension de celui que j'ai écrit sur Golf, un nombre plus grand que TREE (3) et l' emporte complètement sur toutes les autres solutions ici pour l'instant.

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

Essayez-le en ligne!

Rubis, ψ 0I (I I )) + 999674 points

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

Essayez-le en ligne! (avertissement: cela ne fera pas grand-chose, car il ne (0..1.0/0).map{...}peut clairement pas se terminer. C'est ainsi que j'imprime également une infinité de programmes.)

Rubis, ψ 0I (0)) + 999697 points

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

Essayez-le en ligne!

Un programme de test plus raisonnable qui implémente à la (0..5).map{...}place:

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

Essayez-le en ligne!

Malheureusement, même avec (1..1).map{...}, vous trouverez que ce programme est extrêmement gourmand en mémoire. Je veux dire, la longueur de la sortie dépasse des choses comme SCG (13).

En utilisant le programme plus simple, nous pouvons considérer quelques valeurs:

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

Essayez-le en ligne!

Il imprime essentiellement le même programme à plusieurs reprises, au format:

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

où l'initialisation xenregistre l'ordinal auquel le programme est lié, et la "..."détient les programmes après xa été réduite. Si x==0, alors il imprime

p

qui est un programme qui n'imprime rien avec un score de zéro, d'où

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

a un score de 1, et

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

a un score de 2, et

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

a un score de 3, etc., et mon programme d'origine imprime ces programmes au format

puts("...")

...sont les programmes énumérés ci-dessus.

Mon programme réel imprime ces programmes au format

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

Infiniment de fois, et pour des valeurs telles que ω, cela fait quelque chose de semblable à

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

Et donc, le score du programme

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

est 1+some_ordinal, et le score de

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

est 1+some_ordinal+1, et le score 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]}\")")

est 1+some_ordinal+2.


Explication des ordinaux:

f[a,n,b]réduit un ordinal a.

Chaque nombre naturel se réduit au nombre naturel en dessous.

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

[c,0,e]est le successeur de c, et il se réduit toujours à c.

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

[c,d,e] est une hyperopération associative à l'envers, se réduit comme suit:

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] est le premier ordinal infini (équivalent à ω) et se réduit comme suit:

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

[c] est le cième oméga ordinal et se réduit comme suit:

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]est ψ d (c) et se réduit comme suit:

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]est fondamentalement le même que [c,d,e], sauf qu'il énumère l'opération [c]au lieu de l'opération qui lui succède.

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]
Art tout simplement magnifique
la source
Selon le wikia de Googology, je suis le premier cardinal inaccessible, ni le premier ordinal inaccessible.
PyRulez
@PyRulez Oui, bien qu'il soit plus logique d'avoir un ordinal ici au lieu d'un cardinal. Habituellement, on dit que Ic'est l'ordinal qui se rapporte au premier cardinal inaccessible, tout comme ω se rapporte à aleph null.
Simply Beautiful Art
4

Java + Brainf ***, ω + 999180 points

Un programme java qui produit une infinité de programmes Brainf ***, dont chacun produit le dernier en sortie.

Pourquoi? Parce que je peux.

Toute amélioration de la partie génération Brainf *** est certainement la bienvenue.

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
la source
1
À votre goût, bien sûr, mais l'utilisation du vrai nom facilite la recherche. :)
luser droog
1
@luserdroog Pas vrai. Comme je suis sûr que vous savez comment inclure plusieurs termes de recherche, il est tout aussi difficile de rechercher des programmes BF avec des noms différents.
mbomb007
@ mbomb007 suggérez-vous que taper "brainfuck | brainf * ck | brainfcuk | brainf ** k | brainf *** | brain **** | brainfu * k | ..." est tout aussi difficile à taper "brainfuck"?
Sparr
@Sparr StackExchange utilise *comme caractère générique, il suffit donc de taper brainf***ou brainf. Toutes ces variations apparaissent dans les résultats de recherche. codegolf.stackexchange.com/help/searching
mbomb007
@ mbomb007 merci, je ne le savais pas
Sparr
4

Alphabétisé Haskell (GHC 7.10): ω² + 999686 points.

Cela servira d'exemple de réponse. Étant donné que c'est un exemple, il est logique d'utiliser une programmation alphabétisée . Cela ne marquera pas bien cependant. Les birdies diminueront mon score, mais bon. D'abord, faisons une fonction d'aide s. Si x est un ordinal, sx = x + 1, mais nous trouvons des utilisations inattendues de s.

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

La fonction show fait heureusement toute la désinfection des cordes pour nous. Cela vaut également la peine de faire 0. Zéro n'est le successeur de rien, mais s "" sera égal à "main = putStrLn" "", ce qui équivaut à 0.

> z=s""

Nous allons maintenant créer une fonction qui prend n et renvoie ω * n.

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

Il fonctionne en faisant ω * n par {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...}. Quel est ce q? Pourquoi, c'est la raison pour laquelle nous avons une balise . q est les fonctions d'assistance ci-dessus jusqu'à présent.

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

Notez que seulement sur les besoins q, aucun de ses successeurs (s (o (n)), s (s (o (n)))), car ils n'ont pas besoin des fonctions d'assistance (sauf indirectement à partir de o n.) Il ne nous reste plus qu'à sortir tout ω * n pour n fini.

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

Et voilà. ω ^ 2 N'ayant utilisé que 314 caractères de code, je réclame un bonus final de 999686, ce qui me donne un score final de ω ^ 2 + 999686, qui est déjà sous la forme normale de Cantor.

Quatre premières lignes de sortie (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
la source
Maintenant, écrivez une solution sérieuse :-)
Simply Beautiful Art
2

GolfScript, ε₀ + 1 + 999537 points

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

Cela peut probablement être mieux, mais je suis devenu trop paresseux pour déboguer et prouver des ordinaux plus gros.

Petits ordinaux

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

Javascript (Nashorn), ω2 + 999807 points

Nashorn est le moteur Javascript intégré à Java. Cela peut également fonctionner dans Rhino, mais je ne l'ai pas encore testé dans cela.

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
la source
Est-ce 2ω ou ω²?
kamoroso94
@ kamoroso94 FYI 2ω = ω.
Simply Beautiful Art
D'accord, ω • 2, mon mauvais.
kamoroso94