आप कर सकते हैं कि सबसे बड़ी अनंत बनाओ!

Question

क्रमसूचक संख्या प्रणाली अनंत संख्या के साथ एक प्रणाली है। बहुत सारी अनंत संख्या। इतनी अनंत संख्याएँ कि इसका शाब्दिक अर्थ अपनी स्वयं की असीमता का प्रतिनिधित्व करने के लिए एक अनंतता नहीं है। ऊपर की छवि थोड़ा सा विचार देती है कि वे कैसे काम करते हैं। एक क्रमिक संख्या ( वॉन न्यूमैन निर्माण ) पिछले अध्यादेशों का एक समूह है। उदाहरण के लिए, 0 खाली सेट है, 1 सेट {0}, 2 सेट {0, 1} और आदि है तो हमें we मिलता है, जो {0, 1, 2, 3 ...} है। ω + 1 है {0, 1, 2, 3 ...,}, {गुणा दो है {0, 1, 2 ... {, ω + 1, ... + 2 ...} और आप बस ऐसे ही चलते रहते हैं उस।

आपका कार्यक्रम ऐसे {0, 1, 4} अध्यादेशों के एक सेट का उत्पादन करेगा। आपका स्कोर तब आपके सेट के सभी अध्यादेशों से कम से कम क्रमिक होगा। {0, 1, 4} के लिए स्कोर होगा 5. {0, 1, 2 ...} के लिए, स्कोर, होगा।

आप अपने अध्यादेशों को किस तरह से पूछते हैं। बेशक कोड। अर्थात्, आपका कार्यक्रम अन्य कार्यक्रमों की एक संभावित अनंत सूची को उद्धरण में, प्रत्येक पंक्ति पर एक (नई लाइनों का प्रतिनिधित्व करने के लिए शाब्दिक स्ट्रिंग "\ n" का उपयोग करेगा) को आउटपुट करेगा। जैसा कि ऊपर बताया गया है, एक कार्यक्रम अपने स्कोर से मेल खाता है। उदाहरण के लिए, यदि आप आउटपुट

"A"
"B"
"C"

जहाँ A, B, और C स्वयं मान्य उत्तर हैं और स्कोर {0, 1, 4} हैं, आपके कार्यक्रम का स्कोर 5. होगा। ध्यान दें कि A, B और C को पूर्ण कार्यक्रम होना है, न कि टुकड़े।

उपरोक्त नियमों के आधार पर, एक प्रोग्राम जो कुछ भी नहीं करता है, उसका स्कोर 0 होता है (सभी {} से कम से कम क्रमिक अधिक)। यह भी याद रखें कि एक सेट नींव के स्वयंसिद्ध माध्यम से खुद को शामिल नहीं कर सकता है । अर्थात्, प्रत्येक सेट (और इसलिए क्रमिक) शून्य के लिए एक रास्ता है। इसका मतलब है कि पूर्ण-क्वीन अमान्य होगा क्योंकि यह एक सेट नहीं है।

इसके अलावा, किसी भी कार्यक्रम को बाहरी संसाधनों (इसकी अपनी फ़ाइल, इंटरनेट आदि ...) तक पहुंचने की अनुमति नहीं है। इसके अलावा, जब आप अपने स्कोर को सूचीबद्ध करते हैं, तो स्कोर के कैंटर को सामान्य रूप में इसके साथ रखें यदि यह पहले से कैंटर के सामान्य रूप में नहीं है, यदि आप (यदि नहीं, तो कोई और कर सकते हैं)।

उपरोक्त सभी को ध्यान में रखने के बाद, आपके द्वारा पोस्ट किया गया वास्तविक उत्तर 1,000,000 बाइट्स के अंतर्गत होना चाहिए (टिप्पणियों की गिनती नहीं)। (यह ऊपरी बाध्य होने की संभावना केवल स्वचालित रूप से उत्पन्न कोड के लिए खेलने में आएगी)। इसके अलावा, आप प्रत्येक बाइट के लिए अपने स्कोर में वृद्धि करते हैं, जिसका आप उपयोग नहीं करते हैं (क्योंकि हम शिशुओं के साथ काम कर रहे हैं, यह संभवतः केवल खाते में आएगा जब अध्यादेश बहुत करीब या समान होते हैं)। फिर, यह पैराग्राफ केवल पोस्ट किए गए उत्तर पर लागू होता है, न कि उत्पन्न लोगों पर, या जो उत्पन्न जनरेट करता है, और इसी तरह।

इसमें क्वीन टैग है, क्योंकि यह बड़े ऑर्डिनल बनाने में उपयोग के लिए, कम से कम स्रोतों के स्वयं के कोड उत्पन्न करने के लिए सहायक हो सकता है। हालांकि इसकी आवश्यकता नहीं है, हालांकि (उदाहरण के लिए, स्कोर 5 के साथ एक सबमिशन को शायद अपने स्वयं के सोर्स कोड की आवश्यकता नहीं होगी)।

एक काम किया और एनोटेट उदाहरण के लिए, यहां देखें ।

Comments

इसका मतलब यह है कि यह कार्डिनल की अनंत संख्या में उत्पादन को समाप्त नहीं करना चाहिए? और प्रतिबंधित-स्रोत हिस्सा कहां है? मुझे लगता है कि यह टैग कोड लंबाई सीमाओं के लिए नहीं है। मुझे उद्धृत \ n में परिवर्तित किए गए और उद्धृत किए गए दोनों बिंदुओं की आवश्यकता मुझे बेमानी लगी, क्या अन्य अंतर्निहित सूची प्रारूपों की अनुमति दी जानी चाहिए?

— jimmy23013

@ user23013 यह आपके विकल्प पर हो सकता है, कभी भी अनंत संख्या में अध्यादेशों का उत्पादन करने के लिए समाप्त न हो। हालाँकि नई-नई पंक्तियों को उद्धृत करना और उनसे बचना निरर्थक है, लेकिन कई भाषाओं ने उस कार्य के लिए सुविधाओं का निर्माण किया है। अन्य सूची स्वरूपों से आपका क्या अभिप्राय है?

— PyRulez

मेरा मतलब किसी भी सूची या सरणी प्रारूप को प्रयुक्त भाषा से पहचानने योग्य है। या केवल कनवर्टिंग \ n वैकल्पिक करें। कई भाषाओं में एक त्वरित सुधार सिर्फ किसी भी नई सीमा का उपयोग नहीं करना है, हालांकि।

— jimmy23013

प्रतिमा खंडित है। " सेट नहीं कर सकता " इसका क्या मतलब है? " आपके द्वारा पोस्ट किया जाने वाला वास्तविक उत्तर 1,000,000 बाइट्स के अंतर्गत होना चाहिए " वास्तविक सीमा की तुलना में बहुत कमजोर है, क्योंकि StackExchange 30000 से अधिक वर्णों के उत्तर की अनुमति नहीं देगा।

— पीटर टेलर

@NateEldredge अलग-अलग शब्दों में, साबित होता है कि एक कम्प्यूटेशनल ऑर्डिनल को गिनने योग्य होना चाहिए।

— बस

Answer 1

हास्केल: ψ (Ω ^{Ω ω} ) + 999,672 अंक

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 बाइट्स के साथ क्रमसूचक ψ (Ω ^{Ω ω} ) + 1. उपयोग एक वृक्ष-आधारित प्रतिनिधित्व द्वारा की खोज की ordinals Jervell (2005) । बच्चों के साथ पेड़ अल्फा , β , ..., γ निरूपित किया जाता है α :@ (β :@ (… :@ (γ :@ Z)…))। यह बाएं से दाएं क्रम जेरवेल से सहमत है, हालांकि ध्यान दें कि मडोर इसे दाएं-बाएं छोड़ता है।

हास्केल: + ₀ + 999777 अंक

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"

क्रमिक inal ₀ + 1 के साथ कोड के 224 बाइट्स । यह बेक्लेमिसहेव वर्म के सामान्यीकरण से लेकर ऑर्डिनल-वैल्यूड एलिमेंट्स पर आधारित है, जो खुद कृमि द्वारा प्रतिनिधित्व करते हैं।

हास्केल: + ₀ + 999853 अंक

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"

अध्यादेश + ₀ + 1. के साथ कोड के 148 बाइट्स यह बेक्लेमिशेव के वर्म पर आधारित है । सूचि

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

क्रमसूचक (ω का प्रतिनिधित्व करता है ^γ + ⋯ + ω ^बीटा + ω ^{अल्फा} ) - 1. तो दूसरे स्तर के आउटपुट [0], [1], [2], [3], ... प्रतिनिधित्व करते हैं 1, ω, ω ^ω , ω ^{ω ω} , ..., प्रथम-स्तर उत्पादन ε का प्रतिनिधित्व करता है ₀ , और प्रारंभिक कार्यक्रम + ₀ + 1 का प्रतिनिधित्व करता है ।

हास्केल: + ₀ + 999807 अंक

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"

अध्यादेश tes ₀ + 1 के साथ कोड के 194 बाइट्स ।

Z0 का प्रतिनिधित्व करता है, और हम पर transfinite शामिल द्वारा साबित कर सकते हैं अल्फा , तो पर β , कि α :@ β≥ ω ^{अल्फा} + β । तो वहाँ कम से कम किसी भी टावर ω के रूप में बड़ी के रूप में दूसरे स्तर के आउटपुट हैं ^{ω ⋰ ω} , जिसका अर्थ है प्रथम स्तर उत्पादन कम से कम ε है ₀ और प्रारंभिक कार्यक्रम कम से कम ε है ₀ + 1।

Comments

अच्छा जवाब। क्या आपको लगता है कि आप इसे और अधिक समझा सकते हैं? मुझे एक सुव्यवस्थित प्रकार का उपयोग करने का आपका विचार पसंद है।

— प्युर्लेज़

विशेष रूप से, यह उत्पादन के रूप में कौन से अध्यादेशों का उत्पादन कर रहा है?

— PyRulez

इसके अलावा, क्या आप जानते हैं कि इन अध्यादेशों के कैंटर का सामान्य रूप क्या है?

— PyRulez

@PyRulez इन अध्यादेशों का वर्णन करने के लिए सामान्य रूप सहायक नहीं है। Ω (Γ₀ ^ Ω ^ ω), and, और Ω सभी एप्सिलॉन संख्याएँ होती हैं , इसलिए जब हम बेकार "समान स्तर" के लिए अपने "एकल-स्तर" कैंटर सामान्य रूप (ψ Ω ^ ω ^ ω) = ω ^ ψ के लिए समान परिपत्र समीकरण लिख सकते हैं ((^ Ω ^ ω), ω = Γ₀ ^ Γ₀, ω = ω ^ cannot), हम उन्हें उन अभिव्यक्तियों के रूप में नहीं लिख सकते हैं जहां हर घातांक सामान्य रूप से कैंटर में सामान्य रूप में होता है।

— एंडर्स केसरगॉव

इसलिए, आपको ऑर्डिनल टकराने वाले कार्यों के लिए एक वेबलेन की तरह सामान्य रूप का उपयोग क्यों करना चाहिए: पी। जैसे, आप Γ₀ = ψ (Ω ^ and) और ψ = ψ (0) लिखेंगे।

— बस सुंदर कला

Answer 2

रूबी, ψ ₀ (ψ _{एक्स (ψ एम + 1 (Ω एम + 1 ^{Ω एम + 1} ))} (0)) + 999,663 अंक

मान लिया जाये कि मैं अपने कार्यक्रम ठीक से समझ, मेरे स्कोर ψ है ₀ (ψ _{एक्स (ψ एम + 1 (Ω एम + 1 ^{Ω एम + 1} ))} (0)) + 999,663 अंक जहां ψ एक क्रमसूचक समारोह गिर है, एक्स ची है फंक्शन (महलो का पतन करने वाला फंक्शन), और एम पहला महलो का 'ऑर्डिनल' है।

यह कार्यक्रम गोल्फ का एक ऐसा विस्तार है, जिसे मैंने TREE (3) की तुलना में बड़े नंबर पर लिखा था और अब के लिए यहां के अन्य सभी समाधानों को पूरी तरह से ट्रम्प कर रहा हूं ।

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

इसे ऑनलाइन आज़माएं!

रूबी, y ₀ (( _I (I ^I )) + 999674 अंक

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

इसे ऑनलाइन आज़माएं! (चेतावनी: यह बहुत कुछ नहीं करेगा, क्योंकि स्पष्ट रूप से (0..1.0/0).map{...}समाप्त नहीं हो सकता। यह है कि मैं असीम रूप से कई कार्यक्रमों को भी प्रिंट करता हूं।)

रूबी, y ₀ (ψ _I (0)) + 999697 अंक

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

इसे ऑनलाइन आज़माएं!

एक अधिक उचित परीक्षण कार्यक्रम जो (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]}\")")}

इसे ऑनलाइन आज़माएं!

दुर्भाग्य से, यहां तक ​​कि (1..1).map{...}आप इस कार्यक्रम को अत्यंत स्मृति गहन पाएंगे । मेरा मतलब है, आउटपुट की लंबाई SCG (13) जैसी चीजों से अधिक है।

सरल प्रोग्राम का उपयोग करके, हम कुछ मूल्यों पर विचार कर सकते हैं:

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

इसे ऑनलाइन आज़माएं!

यह मूल रूप से एक ही प्रोग्राम को बार-बार प्रिंट करता है:

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

जहां प्रारंभिक xरिकॉर्ड में क्रमिक कार्यक्रम से संबंधित है, और कम "..."होने के बाद कार्यक्रम आयोजित करता है x। यदि x==0, तो यह प्रिंट करता है

p

जो एक कार्यक्रम है जो शून्य के स्कोर के साथ कुछ भी प्रिंट नहीं करता है, इसलिए

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

1 का स्कोर है, और

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

2 का स्कोर है, और

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

3 का स्कोर है, आदि, और मेरा मूल कार्यक्रम इन कार्यक्रमों को प्रारूप में प्रिंट करता है

puts("...")

...ऊपर सूचीबद्ध कार्यक्रम कहां हैं।

मेरा वास्तविक कार्यक्रम वास्तव में इन कार्यक्रमों को प्रारूप में प्रिंट करता है

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

असीम रूप से कई बार, और जैसे मूल्यों के लिए ω, यह कुछ करने के लिए समान है

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

और इस प्रकार, कार्यक्रम का स्कोर

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

है 1+some_ordinal, और का स्कोर

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

है 1+some_ordinal+1, और का स्कोर

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।

---

अध्यादेशों की व्याख्या:

f[a,n,b]एक ऑर्डिनल कम कर देता है a।

प्रत्येक प्राकृतिक संख्या उसके नीचे की प्राकृतिक संख्या को कम कर देती है।

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

[c,0,e]का उत्तराधिकारी है c, और यह हमेशा कम हो जाता है c।

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

[c,d,e] एक पिछड़े साहचर्य अतिवृद्धि है, निम्नानुसार हैं:

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] पहला अनंत ऑर्डिनल (to के बराबर) है और निम्नानुसार है:

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

[c] cth ओमेगा ऑर्डिनल है और निम्नानुसार है:

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]is _d (c) है और निम्नानुसार है:

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]मूल रूप से एक ही है [c,d,e], सिवाय [c]इसके कि यह उत्तराधिकारी ऑपरेशन के बजाय ऑपरेशन पर गणना करता है।

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]

Comments

गोगोलॉजी विकिया के अनुसार, मैं पहला दुर्गम कार्डिनल हूं, न ही पहला दुर्गम ऑर्डिनल।

— पाइरुलज़

@PyRulez हां, हालांकि कार्डिनल के बजाय यहां एक ऑर्डिनल का होना अधिक मायने रखता है। आमतौर पर कोई कहता है कि Iवह अध्यादेश है जो पहले दुर्गम कार्डिनल से संबंधित है, ठीक उसी तरह जैसे कि ull एलेफिक नल से संबंधित है।

— बस सुंदर कला

Answer 3

जावा + ब्रेनफ़ ***, 999 + 999180 अंक

एक जावा प्रोग्राम जो असीम रूप से कई ब्रेनफ *** प्रोग्राम का निर्माण करता है, जिनमें से प्रत्येक आउटपुट के रूप में अंतिम का उत्पादन करता है।

क्यूं कर? क्योंकि मैं कर सकता हूँ।

ब्रेनफ *** पीढ़ी के हिस्से में कोई सुधार निश्चित रूप से स्वागत योग्य है।

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

Comments

अपने स्वाद के लिए, निश्चित रूप से, लेकिन असली नाम का उपयोग करने से खोज करना आसान हो जाता है। :)

— लूसर डॉग

@luserdroog सत्य नहीं है। चूंकि मुझे यकीन है कि आप जानते हैं कि कई खोज शब्दों को कैसे शामिल किया जाए, इसलिए अलग-अलग नामांक वाले बीएफ कार्यक्रमों की खोज करना समान कठिनाई है।

— mbomb007 10

@ mbomb007 क्या आप यह सुझाव दे रहे हैं कि टाइपिंग "brainfuck | brainf * | ck | brainfccoo | xf ** k।। brainf *** *** | brain **** | brainfu * k | ..." टाइप करने में समान कठिनाई होती है "brainfuck"।

— स्पर्म

@Sparr StackExchange *एक वाइल्डकार्ड वर्ण के रूप में उपयोग करता है , इसलिए बस टाइप करें brainf***, या brainf। खोज परिणामों में वे सभी विविधताएँ सामने आती हैं। codegolf.stackexchange.com/help/searching

— mbomb007

@ mbomb007 धन्यवाद, मुझे नहीं पता था कि

— Sparr

Answer 4

साहित्य हास्केल (GHC 7.10): 6 + 999686 अंक।

यह एक उदाहरण के जवाब के रूप में काम करेगा। अपने उदाहरण के बाद से, यह केवल साक्षर प्रोग्रामिंग का उपयोग करने के लिए समझ में आता है । हालांकि यह अच्छा स्कोर नहीं करेगा। बर्डीज़ मेरा स्कोर कम कर देंगे, लेकिन ओह अच्छा। सबसे पहले, चलो एक सहायक कार्य करते हैं। यदि x एक क्रमिक है, तो sx = x + 1 है, लेकिन हम s का अप्रत्याशित उपयोग करते हैं।

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

शो फंक्शन सौभाग्य से हमारे लिए सभी स्ट्रिंग सैनिटाइजेशन करता है। इसका बनाने लायक भी 0. शून्य किसी भी चीज का उत्तराधिकारी नहीं है, लेकिन "" "" मुख्य = putStrLn "" के बराबर होगा, जो 0 के बराबर है।

> z=s""

अब हम एक फ़ंक्शन बनाएंगे जो n लेता है, और n * n देता है।

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

यह {by * (n-1), n ​​* (n-1) +1,-* (n-1) +2, ...} द्वारा n * n बनाकर काम करता है। यह क्यू क्या है? क्यों, इसका कारण हमारे पास एक क्वीन टैग है। क्यू अब तक उपर्युक्त सहायक कार्य है।

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

ध्यान दें कि केवल जरूरत पर ही क्यू, इसके किसी भी उत्तराधिकारी (ओं (n)), s (s (o (n))) की जरूरत नहीं है, क्योंकि उन्हें सहायक कार्यों (अप्रत्यक्ष रूप से o n को छोड़कर) की आवश्यकता नहीं है। अब हमें केवल परिमित n के लिए only * n का उत्पादन करना है।

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

हम वहाँ चलें। ω ^ 2 में केवल 314 कोड चरित्र का उपयोग किया गया है, मैं 999686 के अंतिम बोनस का दावा करता हूं, जिससे मुझे 999 ^ 2 + 999686 का अंतिम स्कोर मिलता है, जो पहले से ही कैंटर के सामान्य रूप में है।

आउटपुट की पहली चार लाइनें (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"

Comments

अब एक गंभीर समाधान लिखिए :-)

— ब्यूटीफुल आर्ट

Answer 5

गोल्फस्क्रिप्ट, Script + 1 + 999537 अंक

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

यह शायद बेहतर हो सकता है, लेकिन मैं डिबग करने और बड़े अध्यादेशों को साबित करने के लिए बहुत आलसी हो गया।

छोटे अध्यादेश

#ω^ω^ω
#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~

Answer 6

जावास्क्रिप्ट (नैशोर्न), +2 + 999807 अंक

नैशॉर्न जावास्क्रिप्ट इंजन है जो जावा में बनाया गया है। यह राइनो में भी काम कर सकता है, लेकिन मैंने अभी तक इसमें परीक्षण नहीं किया है।

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

Comments

यह 2ω² या ω² है?

— kamoroso94

@ kamoroso94 FYI 2ω = FY

— बस सुंदर कला

ठीक है, ω • 2, मेरा बुरा।

— 20