สร้างอินฟินิตี้ที่ใหญ่ที่สุดที่คุณสามารถทำได้!


31

แบบฟอร์มต้นเสียงปกติ

ระบบเลขลำดับเป็นระบบที่มีหมายเลขอนันต์ มีจำนวนอนันต์มากมาย จำนวนอนันต์มากมายที่แท้จริงไม่มีอินฟินิตี้แทนความอนันต์ของมัน ภาพด้านบนเป็นแนวคิดเล็กน้อยเกี่ยวกับวิธีการทำงาน เลขลำดับ (โครงสร้างVon Neumann ) เป็นชุดของเลขลำดับก่อนหน้า ตัวอย่างเช่น 0 คือชุดว่าง 1 คือชุด {0}, 2 คือชุด {0, 1} และอื่น ๆ จากนั้นเราจะได้รับ to ซึ่งคือ {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 (ลำดับที่น้อยที่สุดที่มากกว่า {} ทั้งหมดคือ 0) ยังจำชุดที่ไม่สามารถมีตัวเองผ่านทางความจริงของมูลนิธิ กล่าวคือทุกชุด (และดังนั้นลำดับ) มีเส้นทางลงไปที่ศูนย์ ซึ่งหมายความว่าการควินเต็มจะไม่ถูกต้องเนื่องจากไม่ใช่ชุด

นอกจากนี้ยังไม่อนุญาตให้โปรแกรมเข้าถึงทรัพยากรภายนอก (ไฟล์ของตัวเอง, อินเทอร์เน็ต ฯลฯ ... ) นอกจากนี้เมื่อคุณทำรายการคะแนนของคุณให้วางแบบฟอร์มต้นเสียงปกติของคะแนนไว้ข้างๆถ้ามันไม่ได้อยู่ในแบบฟอร์มต้นเสียงปกติแล้วถ้าคุณทำได้ (ถ้าไม่ใช่คนอื่นก็ทำได้)

หลังจากพิจารณาทั้งหมดข้างต้นแล้วคำตอบจริงที่คุณโพสต์ต้องมีขนาดไม่เกิน 1,000,000 ไบต์ (ไม่นับความคิดเห็น) (ขอบเขตบนนี้มีแนวโน้มที่จะเล่นได้เฉพาะรหัสที่สร้างขึ้นโดยอัตโนมัติ) นอกจากนี้คุณจะได้รับคะแนนของคุณเพิ่มขึ้นสำหรับแต่ละไบต์ที่คุณไม่ได้ใช้ (เนื่องจากเรากำลังติดต่อกับอินฟินิตี้สิ่งนี้อาจนำมาพิจารณาเฉพาะเมื่อกฎอยู่ใกล้หรือเหมือนกัน) อีกย่อหน้านี้ใช้กับคำตอบที่โพสต์ไม่ใช่คำที่สร้างขึ้นหรือคำที่สร้างขึ้นที่สร้างขึ้นและอื่น ๆ

นี่คือแท็ก quine เพราะมันอาจเป็นประโยชน์ในการสร้างอย่างน้อยส่วนหนึ่งของรหัสแหล่งที่มาของตัวเองเพื่อใช้ในการสร้างลำดับขนาดใหญ่ ไม่จำเป็นต้องใช้วิธีนี้ (ตัวอย่างเช่นการส่งด้วยคะแนน 5 อาจไม่ต้องการซอร์สโค้ดของมันเอง)

สำหรับการทำงานออกและเป็นตัวอย่างข้อเขียนดูที่นี่


หมายความว่าไม่ควรยุติการส่งออกจำนวนคาร์ดินัลที่ไม่สิ้นสุด? และส่วนที่ถูก จำกัด อยู่ที่ไหน ฉันคิดว่าแท็กนี้ไม่ได้มีไว้สำหรับการจำกัดความยาวของรหัส ต้องการทั้งข้อความที่ยกมาและบรรทัดใหม่ที่แปลงเป็น \ n ดูเหมือนจะซ้ำซ้อนกับฉันควรอนุญาตรูปแบบรายการในตัวอื่น ๆ ได้หรือไม่
jimmy23013

@ user23013 มันอาจเป็นไปได้ที่คุณจะไม่สิ้นสุดเพื่อส่งออกจำนวนอนันต์ แม้ว่าการอ้างอิงและการขึ้นบรรทัดใหม่นั้นซ้ำซ้อนหลายภาษาได้สร้างสิ่งอำนวยความสะดวกสำหรับงานนั้น รูปแบบรายการอื่น ๆ คุณหมายถึงอะไร
PyRulez

ฉันหมายถึงรายการหรือรูปแบบอาร์เรย์ใด ๆ ที่ใช้โดยภาษาที่รู้จัก หรือเพียงแค่แปลง \ n เป็นตัวเลือก การแก้ไขอย่างรวดเร็วในหลายภาษาคือการไม่ใช้บรรทัดใหม่ใด ๆ
jimmy23013

3
ภาพเสีย "การตั้งค่าไม่สามารถทำได้ " หมายถึงอะไร " คำตอบจริงที่คุณโพสต์ต้องมีขนาดไม่เกิน 1,000,000 ไบต์ " นั้นอ่อนแอกว่าขีด จำกัด จริงเนื่องจาก StackExchange ไม่อนุญาตให้มีคำตอบเกิน 30000 ตัวอักษร
Peter Taylor

1
@NateEldredge Worded แตกต่างกันพิสูจน์ว่าลำดับที่คำนวณได้จะต้องนับ
ศิลปะที่สวยงามเพียง

คำตอบ:


20

Haskell: ψ (โอห์มโอห์มโอห์ม ) + 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 ใช้เป็นตัวแทนของต้นไม้ตามเลขค้นพบโดยJervell (2005) ต้นไม้ที่มีเด็กแอลฟา , β , ... , γα :@ (β :@ (… :@ (γ :@ Z)…))คือเข็มทิศ คำสั่งจากซ้ายไปขวานี้เห็นด้วยกับ Jervell ถึงแม้ว่าทราบว่า Madore พลิกมันจากขวาไปซ้าย

Haskell: Γ 0 + 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"

โค้ดขนาด 224 ไบต์พร้อมเลขลำดับ 1. 0 + 1 สิ่งนี้ขึ้นอยู่กับลักษณะทั่วไปของเวิร์มของ Beklemishev ไปยังองค์ประกอบที่มีค่าตามลำดับซึ่งตัวมันเองเป็นตัวแทนของเวิร์ม

Haskell: ε 0 + 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"

148 ไบต์ของรหัสที่มีลำดับε 0 + 1 นี้จะขึ้นอยู่กับหนอน Beklemishev ของ รายการ

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

หมายถึงลำดับ (ω แกมมา + + ⋯ω บีตา + ω อัลฟ่า ) - 1. ดังนั้นผลระดับที่สอง[0], [1], [2], [3]... เป็นตัวแทน 1 ω, ω ω , ω ω ω , ... , เอาท์พุทระดับแรกหมายถึงε 0และโปรแกรมเริ่มต้นแสดงถึงε 0 + 1

Haskell: ε 0 + 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"

194 ไบต์ของรหัสที่มีลำดับε 0 + 1

Zแทน 0 และเราสามารถพิสูจน์โดยอุปนัย transfinite บนαแล้วในβที่α :@ β≥โอห์มα + β ดังนั้นจึงมีผลระดับที่สองอย่างน้อยเป็นใหญ่เป็นหอใด ๆ โอห์มโอห์มโอห์มซึ่งหมายความว่าระดับแรกการส่งออกเป็นอย่างน้อยε 0และโปรแกรมเริ่มต้นเป็นอย่างน้อยε 0 + 1


2
คำตอบที่ดี คุณคิดว่าคุณสามารถอธิบายเพิ่มเติมได้หรือไม่ ฉันชอบความคิดของคุณในการใช้งานประเภทที่ได้รับคำสั่งอย่างดี
PyRulez

1
โดยเฉพาะมันเป็นกฎที่ผลิตเป็นเอาท์พุท?
PyRulez

คุณทราบหรือไม่ว่ารูปแบบปกติของคันทอร์ของกฎเหล่านี้?
PyRulez

@PyRulez Cantor แบบฟอร์มปกติไม่เป็นประโยชน์สำหรับการอธิบายกฎเหล่านี้ ψ (Ω ^ Ω ^ ω), Γ₀, และε₀เป็นตัวเลขเอปไซลอนทั้งหมดดังนั้นในขณะที่เราสามารถเขียนสมการวงกลมที่คล้ายกันสำหรับรูปแบบปกติ "ระดับเดียว" ต้นเสียงคันทอร์ (ψ (Ω ^ Ω ^ =) = ω ^ ψ (Ω ^ Ω ^ ω), Γ₀ = ω ^ Γ₀, ε₀ = ω ^ ε₀) เราไม่สามารถเขียนเป็นนิพจน์ที่ทุกเลขชี้กำลังอยู่ในรูปแบบปกติของคันทอร์ซ้ำ
Anders Kaseorg

1
ดังนั้นทำไมคุณควรใช้รูปแบบปกติเหมือน Veblen สำหรับฟังก์ชันการยุบตามลำดับ: p เช่นนี้คุณจะเขียนΓ₀ = ψ (Ω ^ Ω) และε₀ = ψ (0)
ศิลปะที่สวยงามเพียง

5

Ruby, ψ 0X (ψ M + 1M + 1 Ω M + 1 )) (0)) + 999663 คะแนน

สมมติว่าฉันเข้าใจโปรแกรมของฉันอย่างถูกต้องคะแนนของฉันคือψ 0X (ψ M + 1M + 1 Ω M + 1 )) (0)) +0,966,663 คะแนนโดยที่ψเป็นฟังก์ชันยุบตัวอันดับXคือไค ฟังก์ชั่น (ฟังก์ชั่นยุบ Mahlo) และMเป็น 'ลำดับ' Mahlo แรก

โปรแกรมนี้เป็นส่วนหนึ่งที่ผมเขียนเกี่ยวกับกอล์ฟเป็นจำนวนมากมีขนาดใหญ่กว่า 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]}\""}

ลองออนไลน์!

Ruby, ψ 0I (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{...}มันไม่สามารถยุติได้อย่างชัดเจนมันเป็นวิธีที่ฉันพิมพ์โปรแกรมมากมายเช่นกัน)

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

ลองออนไลน์!

โปรแกรมทดสอบที่สมเหตุสมผลมากขึ้นที่ใช้(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] เป็น hyperoperation ที่สัมพันธ์กันแบบย้อนหลังซึ่งจะลดดังต่อไปนี้:

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] เป็นลำดับที่ไม่มีที่สิ้นสุดแรก (เทียบเท่าω) และลดดังนี้:

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

[c] เป็นลำดับ cth omega และลดดังนี้:

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) และลดดังนี้:

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]

ตาม wogia ของ Googology ฉันเป็นคนแรกที่ไม่สามารถเข้าถึงพระคาร์ดินัลและไม่สามารถเข้าถึงลำดับแรกได้
PyRulez

@PyRulez ใช่แม้ว่ามันจะมีเหตุผลมากกว่าที่จะมีลำดับที่นี่แทนที่จะเป็นพระคาร์ดินัล มักจะกล่าวว่าIเป็นลำดับที่เกี่ยวข้องกับพระคาร์ดินัลไม่สามารถเข้าถึงได้แรกเช่นเดียวกับωเกี่ยวข้องกับ aleph null
ศิลปะที่สวยงามเพียง

4

Java + Brainf ***, ω + 999180 คะแนน

โปรแกรมจาวาที่สร้างโปรแกรม Brainf *** จำนวนมากซึ่งแต่ละโปรแกรมสร้างผลลัพธ์สุดท้ายเป็นเอาต์พุต

ทำไม? เพราะฉันทำได้.

การปรับปรุงส่วนของ Brainf *** ยินดีต้อนรับแน่นอน

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

1
สำหรับรสนิยมของคุณแน่นอน แต่การใช้ชื่อจริงทำให้การค้นหาง่ายขึ้น :)
luser droog

1
@luserdroog ไม่จริง เนื่องจากฉันแน่ใจว่าคุณรู้วิธีรวมคำค้นหาหลายคำมันเป็นเรื่องยากพอ ๆ กันในการค้นหาโปรแกรม BF ที่มีชื่อต่างกัน
mbomb007

@ mbomb007 คุณแนะนำว่าการพิมพ์ "brainfuck | brainf * ck | brainfcuk | brainf ** k | brainf *** | brain **** | brainfu * k | ... " มีความยากเท่ากับการพิมพ์ "brainfuck" หรือไม่?
Sparr

@Sparr StackExchange ใช้*เป็นอักขระตัวแทนดังนั้นเพียงแค่พิมพ์หรือbrainf*** brainfรูปแบบเหล่านั้นทั้งหมดเกิดขึ้นในผลการค้นหา codegolf.stackexchange.com/help/searching
mbomb007

@ mbomb007 ขอบคุณฉันไม่รู้
Sparr

4

Literate Haskell (GHC 7.10): ω² + 999686 คะแนน

สิ่งนี้จะทำหน้าที่เป็นคำตอบตัวอย่าง ตั้งแต่ตัวอย่างของมันก็มี แต่จะทำให้ความรู้สึกที่จะใช้การเขียนโปรแกรมความรู้ มันจะไม่ทำคะแนนได้ดี เบอร์ดี้จะลดคะแนนของฉัน แต่แหมดี อันดับแรกให้สร้างฟังก์ชันผู้ช่วย ถ้า x เป็นเลขลำดับ sx = x + 1 แต่เราพบการใช้งานที่ไม่คาดคิดของ s

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

ฟังก์ชั่นการแสดงโชคดีที่จะทำให้การสุขาภิบาลสตริงทั้งหมดสำหรับเรา มันก็คุ้มที่จะทำให้ 0 เป็นศูนย์ไม่ใช่ผู้สืบทอดของอะไรเลย แต่ s "" จะเท่ากับ "main = putStrLn" "" ซึ่งเท่ากับ 0

> z=s""

ตอนนี้เราจะสร้างฟังก์ชั่นที่รับ n และคืนค่าω * n

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

มันทำงานได้โดยการทำให้ω * n โดย {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ... } q นี้คืออะไร? ทำไมมันเป็นเหตุผลที่เรามีแท็กq คือฟังก์ชันตัวช่วยด้านบน

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

โปรดทราบว่าเฉพาะในความต้องการ q ไม่ใช่ผู้สืบทอด (s (o (n)), s (s (o)))) เนื่องจากพวกเขาไม่ต้องการฟังก์ชันผู้ช่วย (ยกเว้นทางอ้อมจาก o n.) ตอนนี้เราต้องส่งออกทั้งหมดของ n * n เพื่อ จำกัด n

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

เราจะไปที่นั่น. ω ^ 2 ใช้อักขระรหัสเพียง 314 ตัวฉันขอโบนัสขั้นสุดท้ายที่ 999,686 ให้คะแนนสุดท้ายกับฉันω ^ 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"

ตอนนี้ไปเขียนวิธีแก้ปัญหาอย่างจริงจัง :-)
ศิลปะที่สวยงามเพียง

2

GolfScript, ε₀ + 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~

1

Javascript (Nashorn), ω2 + 999807 คะแนน

Nashornเป็นเอ็นจิ้น Javascript ที่มาพร้อมกับ Java สิ่งนี้อาจใช้ได้ในแรด แต่ฉันยังไม่ได้ทดสอบในตอนนั้น

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

มันคือ2ωหรือω²?
kamoroso94


โอเคω• 2 ฉันไม่ดี
kamoroso94
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.