ท้าทาย

ค้นหานิพจน์ที่มีความยาวไม่เกิน 100 ไบต์ด้วยลายเซ็นชนิดที่ยาวที่สุด

กฎระเบียบ

• อนุญาตให้ใช้ภาษาที่พิมพ์แบบสแตติกที่มีการอนุมานประเภท
• ประเภทต้องไม่คลุมเครือ แต่อย่างอื่นอาจรวมถึงประเภทที่ไม่มีอินสแตนซ์ที่กำหนดไว้ ตัวอย่างเช่นNum [a]และEq [a]ได้รับอนุญาตแม้ไม่มีอินสแตนซ์ที่กำหนดไว้
• ไม่มีการนำเข้าอื่นนอกจากขั้นต่ำที่จำเป็นในการรวบรวมโปรแกรมด้วย STDIN / STDOUT
• ไม่อนุญาตประเภทอนันต์
• หากคำตอบมีมากกว่าหนึ่งการแสดงออกเพียงหนึ่งอาจส่งผลให้คะแนน ตัวอย่างเช่นแม้ว่าลายเซ็นประเภทของการแต่งเพลงจะ(.) :: (b -> c) -> (a -> b) -> a -> cมีคะแนน 20 แต่คำตอบที่มี 25 สำเนา(.)\nจะมีคะแนนเท่ากับ 20 ไม่ใช่ 500
• นิพจน์ต้องมีขนาดไม่เกิน 100 ไบต์
• คะแนนคือจำนวนตัวอักษรในลายเซ็นประเภทไม่รวมชื่อของฟังก์ชั่นและช่องว่างใด ๆ ตัวอย่างเช่นf :: (a -> b) -> a -> bจะมีคะแนน 12
• คะแนนสูงสุดชนะ!

ตัวอย่าง

แม้ว่าจะอนุญาตให้ใช้ภาษาอื่น แต่ตัวอย่างต่อไปนี้อยู่ใน Haskell:

Score: 112
map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map
f :: (a -> b)
 -> [[[[[[[[[[[[[[[[[[[[[[[[[a]]]]]]]]]]]]]]]]]]]]]]]]]
 -> [[[[[[[[[[[[[[[[[[[[[[[[[b]]]]]]]]]]]]]]]]]]]]]]]]]    

Score: 240
(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.)
f :: (b->c)->(a->a1->a2->a3->a4->a5->a6->a7->a8->a9->a10->a11->a12->a13->a14->a15->a16->a17->a18->a19->a20->a21->a22->a23->a24->b)->a1->a2->a3->a4->a5->a6->a7->a8->a9->a10->a11->a12->a13->a14->a15->a16->a17->a18->a19->a20->a21->a22->a23->a24->c

Score: 313
foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl(.)
f :: (Foldable t, Foldable t1, Foldable t2, Foldable t3, Foldable t4,
  Foldable t5, Foldable t6, Foldable t7, Foldable t8, Foldable t9,
  Foldable t10, Foldable t11, Foldable t12, Foldable t13,
  Foldable t14, Foldable t15) =>
 (b -> c)
 -> t (t1 (t2 (t3 (t4 (t5 (t6 (t7 (t8 (t9 (t10 (t11 (t12 (t13 (t14 (t15 (b
 -> b))))))))))))))))
 -> b
 -> c

Score: 538
lex.show.foldl1.mapM.traverse.sum.mapM.sum.traverse.(.).mapM.scanl.zipWith3((.traverse).(.traverse))
 (Num
    (a -> ([[c]] -> t3 [[a1 -> f b]]) -> [[c]] -> t3 [[a1 -> f b]]),
  Num
    (([[c]] -> t3 [[a1 -> f b]])
     -> t1 (t2 ([[c]] -> t3 [[a1 -> f b]]))
     -> [[c]]
     -> t3 [[a1 -> f b]]),
  Show
    (t (t1 (t2 ([[c]] -> t3 [[a1 -> f b]])))
     -> t1 (t2 ([[c]] -> t3 [[a1 -> f b]]))),
  Applicative f, Foldable t,
  Foldable ((->) (t1 (t2 ([[c]] -> t3 [[a1 -> f b]])) -> a)),
  Foldable
    ((->) (([[c]] -> t3 [[a1 -> f b]]) -> a -> t3 [a1 -> f b])),
  Traversable t1, Traversable t2, Traversable t3, Traversable t4,
  Traversable t5,
  Traversable ((->) (t1 (t2 ([[c]] -> t3 [[a1 -> f b]])))),
  Traversable ((->) ([[c]] -> t3 [[a1 -> f b]]))) =>
 [(t5 (t4 a1) -> f (t5 (t4 b))) -> c -> a1 -> f b]
 -> [(String, String)]

Haskell, ~ 2 ^ (2 ^ 18)

f x=(x,x)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l.l
n=m.m.m.m
n.n.n.n$0

แอพลิเคชันของแต่ละfประมาณสองเท่าของลายเซ็นชนิดโดยการเปลี่ยนลายเซ็นชนิดไปT (T,T)ตัวอย่างเช่นองค์ประกอบสี่เท่าf.f.f.f$0มีประเภท

Num a => ((((a, a), (a, a)), ((a, a), (a, a))), (((a, a), (a, a)), ((a, a), (a, a))))

แต่ละบรรทัดจะเพิ่มจำนวนแอปพลิเคชั่fน4^9 = 2^18เป็นสี่เท่าเมื่อสิ้นสุด 2^(2^18)ดังนั้นลายเซ็นชนิดมีขนาดของคำสั่งของ

Java, คะแนน 17301488

ต้องการวิธีการ<T>java.util.Map<T,T>f(T t){return null;}ซึ่งนับรวมในขีด จำกัด 100 ไบต์

f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(1)))))))))))))))))))

ลายเซ็นประเภทเวลารวบรวมของสิ่งนี้ควรตรงกับสิ่งนี้

Haskellพร้อมส่วนขยาย, $\ggg A(A(A(A(220,0),0),0),0)$

Z::Z#Z#Z#Z#Z#Z#Z#Z#Z?Z
data a?b=Z|S(a?b)
type family m#n where Z#n=S n;S m#Z=m#S m;S m#S n=m#(S m#n)

ลองออนไลน์!

ต้อง-XDataKinds, -XPolyKinds, -XTypeOperators, และ-XUndecidableInstances-XTypeFamilies

ขอบคุณมากที่ Orjan #ฮันเซนที่ตระหนักว่าการทำมัดจำนวนธรรมชาติคอนสตรัคและการสร้างความขัดแย้งแตกต่างกันเล็กน้อยบันทึกไบต์ที่สองทำให้ห้องพอเพียงสำหรับการทำซ้ำอีก

เห็นได้ชัดว่าตัวตรวจสอบประเภทจะยอมแพ้พยายามที่จะตรวจสอบโปรแกรมนี้ เพื่อให้เข้าใจถึงลักษณะทั่วไปของลายเซ็น (ถ้ามีขนาดเล็กพอที่จะพอดีกับเอกภพที่สังเกตได้) ให้ลองเล็กลง

Z::S(S Z)#Z?Z

คำอธิบาย

#ประเภทครอบครัวมีความเกี่ยวข้องอย่างใกล้ชิดฟังก์ชั่น Ackermann-Peterทั่วไปเขียนแต่เติบโตเร็วมากขึ้น กำหนดฟังก์ชัน Ackermann – Péter$A$#

$A(0,n)=n+1$

$A(m,0)=A(m-1,1)$เมื่อ$m > 0$

$A(m,n)=A(m-1, A(m, n-1))$เมื่อ$m, n > 0$

#ในทางกลับกันเราสามารถโทรหา$B$และเขียนได้

$B(0,n)=n+1$

$B(m,0)=B(m-1,m)$เมื่อ$m > 0$

$B(m,n)=B(m-1, B(m, n-1))$เมื่อ$m,n > 0$

$A$$B(m,n) \ge A(m,n)$$m$$n$

ที่นี่เราคำนวณการเป็นตัวแทนของ unary

$r = B(B(B(B(B(B(B(B(0,0),0),0),0),0),0),0),0)$

$B(B(B(B(0,0),0),0),0)=220$

$r = B(B(B(B(220,0),0),0),0)$

$A(A(A(A(0,0),0),0),0)$$5$$B$$A$

$A(6,0)$

คำจำกัดความของตัวเลขธรรมชาติ(?)เป็นบิตที่ไม่ได้มาตรฐาน เพื่อประหยัดพื้นที่เราใช้(?)ทั้งประเภทหมายเลขธรรมชาติ (ที่ระดับประเภท) และประเภทพร็อกซี (ที่ระดับคำ)

ฉันเชื่อว่าอย่างใดอย่างหนึ่งTypeFamiliesหรือ (มากขึ้นอย่าง verbosely และ obfuscatedly) FunctionalDependenciesมีความจำเป็นเพื่อให้ได้การคำนวณระดับประเภทที่จำเป็นในการเข้าถึงประเภทที่มีขนาดใหญ่อย่างแท้จริง UndecidableInstancesเป็นสิ่งจำเป็นในการหลีกเลี่ยงการตรวจสอบการสิ้นสุดดั้งเดิมของ Haskell ส่วนขยายอื่น ๆ จำเป็นต้องใช้ในการบีบอัดรหัสลงในพื้นที่ที่มีขนาดเล็กเท่านั้น

Haskell, 9 · 2 ⁶⁶³⁵⁵² - 3 (≈ 1.02 · 10 ¹⁹⁹⁷⁵⁰ )

ขนาดเล็ก (“เล็ก”) ปรับปรุงกว่าXNOR ของ5⋅2 ^262,144 + 5 นี่คือ 99 ไบต์

f=(:).(:)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l
n=m.m.m
o=n.n.n
o.o.o

มันทำงานอย่างไร

เรามี

(:)         :: a -> [a] -> [a]
(:).(:)     :: a -> [[a] -> [a]] -> [[a] -> [a]]
(:).(:).(:) :: a -> [[[a] -> [a]] -> [[a] -> [a]]] -> [[[a] -> [a]] -> [[a] -> [a]]]

และอื่น ๆ ด้วยความยาวประมาณสองเท่าสำหรับแต่ละ(:)อัน การแสดงออกให้o.o.oทำงานออกไป(:).(:).(:).….(:)มี 2 · 4 ⁶ · 3 ⁴ = 663,552 (:)สำเนาของ

Haskell with FlexibleContextsand NoMonomorphismRestriction, (200 · 4 ³³¹⁷⁷⁶ + 75 · 331776 + 16) / 9 ≈ 2.53 · 10 ¹⁹⁹⁷⁵⁰

การปรับปรุงเล็กน้อยของ Bubbler 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 - 4 ≈ 1.36 · 10 ¹⁹⁹⁷⁵⁰ซึ่งขึ้นอยู่กับส่วนขยายเหล่านี้ด้วย ถ้อยคำของความท้าทายที่เรียงลำดับชี้ให้เห็นว่ามันอาจโอเคที่จะพึ่งพาพวกเขา (“ ยกตัวอย่างNum [a]และEq [a]ได้รับอนุญาตแม้ไม่มีตัวอย่างที่กำหนดไว้”); ฉันไม่แน่ใจ. นี่คือ 100 ไบต์

f=(/).(:)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l
n=m.m.m
o=n.n.n
-o.o.o

มันทำงานอย่างไร

เรามี

-(/).(:) :: (Fractional ([a] -> [a]), Num (a -> ([a] -> [a]) -> [a] -> [a])) => a -> ([a] -> [a]) -> [a] -> [a]
-(/).(:).(/).(:) :: (Fractional ([a] -> [a]), Fractional ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]), Num (a -> ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]])) => a -> ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]
-(/).(:).(/).(:).(/).(:) :: (Fractional ([a] -> [a]), Fractional ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]), Fractional ([([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]), Num (a -> ([([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]) -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]])) => a -> ([([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]) -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]

และอื่น ๆ ด้วยความยาวประมาณสี่เท่าสำหรับแต่ละ(/).(:)ตัว การแสดงออกให้-o.o.oทำงานออกไป-(/).(:).(/).(:).….(/).(:)4 ⁶ · 3 ⁴ = 331,776 (/).(:)สำเนาของ

Haskell, 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 - 4

อีกปรับปรุงเล็กกว่าคำตอบของแอนเดอ Kaseorg

f=(/).(/)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l
n=m.m.m
o=n.n.n
o.o.o

มันทำงานอย่างไร

(/) -- score 27
   :: Fractional a => a -> a -> a
(/).(/) -- score 62
   :: (Fractional a, Fractional (a -> a)) => a -> (a -> a) -> a -> a
(/).(/).(/) -- score 119
   :: (Fractional a, Fractional (a -> a), Fractional ((a -> a) -> a -> a)) =>
      a -> ((a -> a) -> a -> a) -> (a -> a) -> a -> a
(/).(/).(/).(/) -- score 224
   :: (Fractional a, Fractional (a -> a),
       Fractional ((a -> a) -> a -> a),
       Fractional (((a -> a) -> a -> a) -> (a -> a) -> a -> a)) =>
      a
      -> (((a -> a) -> a -> a) -> (a -> a) -> a -> a)
      -> ((a -> a) -> a -> a)
      -> (a -> a)
      -> a
      -> a

องค์ประกอบของฟังก์ชั่นการเปลี่ยนแปลงเพียงแค่การแบ่งเศษส่วน(.) ส่วนร่วมในการระเบิดลายเซ็นของฟังก์ชั่นพร้อมด้วยส่วนหลักให้ตัวคูณคงที่สูงขึ้นเล็กน้อย(/)Fractional x

C, 979

#define a int,int,int
#define b a,a,a,a
#define c b,b,b
#define d c,c,c
#define e d,d,d
int(*f)(e);

f มีลายเซ็น:

int(*)(int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int)

C ++ 11 ไม่ใช่การแข่งขัน

ฉันแทบจะไม่สามารถรับสิ่งนี้ได้ต่ำกว่า 100 ไบต์ แต่ฉันคิดว่าฉันอาจโพสต์ได้ใกล้เพราะหวังว่าจะมีใครเห็นการเพิ่มประสิทธิภาพ

นี่เป็นอารัมภบทซึ่งคิดต้นทุน 93 ไบต์:

#define t(a,b,c)template<a>union A b{using T=c(*)(c);};
t(int N,,typename A<N-1>::T)t(,<0>,A)

และการแสดงออก 9 ไบต์:

A<9>::T()

เพื่อแสดง:

Expr       Type
A<0>::T()  A<0> (*)(A<0>)
A<1>::T()  A<0> (*(*)(A<0> (*)(A<0>)))(A<0>)
A<2>::T()  A<0> (*(*(*)(A<0> (*(*)(A<0> (*)(A<0>)))(A<0>)))(A<0> (*)(A<0>)))(A<0>)

ประมาณสองเท่าทุกครั้งที่จำนวนเพิ่มขึ้น

C #, 363

นิพจน์:

new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=""}}}}}}}}}}}}}}

พิมพ์ลายเซ็น:

<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[System.String]]]]]]]]]]]]]]

ลองออนไลน์!

ไปที่ 1.0 โดยไม่ต้องreflect98

ประเภท 1.x ไปถูกกำหนดแบบคงที่ นี่คือความพยายามครั้งแรกของฉัน:

[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]string{}

ไปที่สนามเด็กเล่น :

package main;import "fmt"
func main() {

    x := [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]string{}

    fmt.Printf("%d %T\n", len(fmt.Sprintf("%T", x)), x)
}

ไป 1.9 โดยใช้นามแฝงประเภท 2389

type(I=interface{f();g()};S=struct{p,q,r,s,t,u,v,w,x,y,z I});map[S]map[S]map[S]map[S]map[S]map[S]S{}

ไปที่สนามเด็กเล่น :

package main;import("fmt";"strings")
func main() {

    type(I=interface{f();g()};S=struct{p,q,r,s,t,u,v,w,x,y,z I});x:=map[S]map[S]map[S]map[S]map[S]map[S]S{}

    fmt.Printf("%d %T\n", len(strings.Replace(fmt.Sprintf("%T", x), " ", "", -1)), x)
}

ผล:

2389 map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }

ไป 1 โดยใช้reflect, 65532

มีข้อ จำกัด ในแพคเกจreflectตามความยาวของชื่อประเภท:len(name) <= 1<<16-1

ฉันสามารถไปถึงชื่อประเภท 65532 ไบต์แล้วด้วยบล็อกนี้:

t:=reflect.TypeOf(0);u:=t;for i:=0;i<8191;i++{t=reflect.MapOf(u,t)};reflect.New(t).Interface()

รหัสเต็มในสนามเด็กเล่น Go :

package main;import("fmt";"reflect")
func main() {

    t:=reflect.TypeOf(0);u:=t;for i:=0;i<8191;i++{t=reflect.MapOf(u,t)};x:=reflect.New(t).Interface()

    fmt.Printf("%d %T\n", len(fmt.Sprintf("%T", x)), x)
}

Idris,> ไฮเปอร์ (ไฮเปอร์ (ไฮเปอร์ (ไฮเปอร์ (999999999, 99, 99), 99,99), 99,99), 99,99))

f:Nat->Type
f Z=()
f(S n)=hyper n n n~=~f n
the$f$hyper(hyper(hyper(hyper 999999999 9 9) 9 9)9 9)9 9

คำอธิบาย:

เรากำหนดฟังก์ชัน f โดยคำนวณประเภท f (0) เป็นเพียงหน่วยประเภทในขณะที่ f (S (n)) คำนวณประเภทความเสมอภาคที่ใช้กับอาร์กิวเมนต์ของฟังก์ชัน "ไฮเปอร์" ด้วยตัวเองและเพื่อนำไปใช้กับ n . บรรทัดสุดท้ายโดยทั่วไปคือฟังก์ชันที่คาดว่าจะมีค่าของประเภทเช่น (27 = (4 = (2 = (1 = ())))))) (สำหรับ n = 4)

ตัวอย่างง่ายๆ

f 3 = (27 = (4 = (2 = (1 = ()))))

Haskell, 782

นิพจน์:

sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum

พิมพ์ลายเซ็น:

:: (Num [[[[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[c]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[c]]]]]]]]]]]]]], Num [[[[[[[[[[[[[c]]]]]]]]]]]]], Num [[[[[[[[[[[[c]]]]]]]]]]]], Num [[[[[[[[[[[c]]]]]]]]]]], Num [[[[[[[[[[c]]]]]]]]]], Num [[[[[[[[[c]]]]]]]]], Num [[[[[[[[c]]]]]]]], Num [[[[[[[c]]]]]]], Num [[[[[[c]]]]]], Num [[[[[c]]]]], Num [[[[c]]]], Num [[[c]]], Num [[c]], Num [c], Num c) => [[[[[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]]]]] -> c

Ceylon, 38843546786070481 (~ 4 · 10 ¹⁶ )

[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

นี่คือ 49 tuples ที่ซ้อนกันโดยมี tuple ด้านในสุดว่าง ชื่อสั้น ๆ ของประเภทนี้จริง ๆ แล้วเหมือนกับค่าในกรณีนี้ แต่ชื่อที่ขยายทั้งหมดจะยาวกว่ามาก

คอมไพเลอร์ Ceylon ทำงานตลอดไปเมื่อพยายามรวบรวมสิ่งนี้ (คอมไพเลอร์ยังคงทำงานหลังจาก 180 นาที) - ฉันจะต้องลองคำนวณความยาวเชิงทฤษฎีประเภท

ปัญหาที่นี่คือประเภทหนึ่งองค์ประกอบ tuple [X]จริง ๆ แล้วแสดงในระบบชนิดของ Ceylon เป็นTuple<X, X, []>(พารามิเตอร์แรกคือ supertype สำหรับทุกองค์ประกอบองค์ประกอบที่สองคือประเภทขององค์ประกอบแรกและที่สามประเภทของทั้งหมดยกเว้นองค์ประกอบแรก ซึ่งนี่คือ tuple ที่ว่างเปล่า ( emptyวัตถุ, อินสแตนซ์เดียวที่พอใจอินเตอร์เฟสEmpty))

ดังนั้น[]เป็นempty, [[]]เป็นTuple<[], [], []>= Tuple<empty, empty, empty>, [[[]]]เป็น=Tuple<[[]], [[]], []> Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []>และชื่อเต็มรวมถึงชื่อแพ็คเกจดังนั้นเราจึงมีceylon.language::Tuple<ceylon.language::Tuple<ceylon.language::empty, ceylon.language::empty, ceylon.language::empty>, ceylon.language::Tuple<ceylon.language::empty, ceylon.language::empty, ceylon.language::empty>, ceylon.language::empty>แค่สามระดับเท่านั้น และเราต้องการไปที่ 50

ในฐานะที่ceylon.language::emptyเป็น 22 ตัวอักษรและแต่ละceylon.language::Tuple<?,?,ceylon.language::empty>เพิ่ม 47 ถึงสองครั้งผลที่ได้จากขั้นตอนก่อนหน้านี้เราได้รับและf(1) = 22 f(n) = 2 · f(n-1) + 47สิ่งนี้ทำให้ง่ายf(n) = 69 · 2^(n - 1) - 47ขึ้นและการป้อน 50 ให้เรา 38843546786070481 แน่นอนว่ามันใหญ่กว่าสิ่งที่จะพอดีกับหน่วยความจำของคอมพิวเตอร์ของฉัน (8 · 10 ⁹ไบต์)

แน่นอนคอมไพเลอร์อาจเป็นสมาร์ทและไม่พยายามมีชื่อประเภททั้งหมดในหน่วยความจำจนกว่าจะมีการร้องขอชื่อ

นี่คือโปรแกรมเต็มรูปแบบที่พยายามพิมพ์ประเภท:

import ceylon.language.meta {
    type
}
"Run the module `codegolf.signature71797`."
shared void run() {
    value x = [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]];
    print(type(x));
}

C # (Visual C # Interactive คอมไพเลอร์) , 99 ไบต์, คะแนน 841

(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,1,1))))))))))))))))))))))))

ลองออนไลน์!

เอาท์พุท

System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`3[System.Int32,System.Int32,System.Int32]]]]]]]]]]]]]]]]]]]]]]]]