Thử thách

Tìm một biểu thức, dài tối đa 100 byte, với chữ ký loại dài nhất.

Quy tắc

• Bất kỳ ngôn ngữ gõ tĩnh nào với kiểu suy luận đều được cho phép
• Loại phải không mơ hồ, nhưng mặt khác có thể bao gồm các loại mà không có trường hợp được xác định. Ví dụ Num [a]và Eq [a]được cho phép, ngay cả khi không có ví dụ xác định
• Không có nhập khẩu nào ngoài mức tối thiểu cần thiết để biên dịch chương trình với STDIN / STDOUT
• Các loại vô hạn không được phép
• Nếu một câu trả lời có nhiều hơn một biểu thức, chỉ một câu có thể đóng góp vào điểm số. Ví dụ: mặc dù chữ ký loại sáng tác là (.) :: (b -> c) -> (a -> b) -> a -> c, có điểm 20, nhưng câu trả lời với 25 bản sao (.)\nsẽ có điểm 20, không phải 500
• Biểu thức phải có nhiều nhất là 100 byte
• Điểm số là số lượng ký tự trong chữ ký loại, không bao gồm tên của hàm và bất kỳ khoảng trắng nào. Ví dụ: f :: (a -> b) -> a -> bsẽ có điểm 12
• Điểm số cao nhất sẽ thắng!

Ví dụ

Mặc dù các ngôn ngữ khác được cho phép, các ví dụ sau có trong 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

Mỗi ứng dụng của fkhoảng gấp đôi chữ ký loại bằng cách chuyển đổi chữ ký loại Tthành (T,T). Ví dụ, thành phần gấp bốn lần f.f.f.f$0có loại

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

Mỗi dòng hình tứ giác số lượng ứng dụng f, đưa ra 4^9 = 2^18ở cuối. Vì vậy, chữ ký loại có kích thước của thứ tự 2^(2^18).

Java, điểm số 17301488

Yêu cầu phương thức <T>java.util.Map<T,T>f(T t){return null;}đã được tính vào giới hạn 100 byte.

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

Chữ ký kiểu thời gian biên dịch của cái này phải khớp với cái này.

Haskell với phần mở rộng, $\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)

Hãy thử trực tuyến!

Đòi hỏi -XDataKinds, -XPolyKinds, -XTypeOperators, -XUndecidableInstances, và -XTypeFamilies.

Rất cám ơn Ørjan Johansen, người đã nhận ra rằng việc tạo hàm xây dựng số tự nhiên và xây dựng các đối số một cách khác nhau đã lưu hai byte, tạo ra đủ chỗ cho một lần lặp khác #.

Rõ ràng, trình kiểm tra loại sẽ từ bỏ cố gắng kiểm tra chương trình này. Để có được ý nghĩa chung về chữ ký sẽ trông như thế nào (nếu nó đủ nhỏ để phù hợp với vũ trụ quan sát được), hãy thử nhỏ hơn nhiều

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

Giải trình

Họ #loại có liên quan chặt chẽ với chức năng Ackermann âm Péter , thường được viết là $A$ , nhưng #phát triển nhanh hơn đáng kể. Hàm Péter của Ackermann được xác định

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

$A(m,0)=A(m-1,1)$ khi$m > 0$

$A(m,n)=A(m-1, A(m, n-1))$ khi$m, n > 0$

#mặt khác, chúng ta có thể gọi và viết$B$

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

$B(m,0)=B(m-1,m)$ khi$m > 0$

$B(m,n)=B(m-1, B(m, n-1))$ khi$m,n > 0$

Chỉ có trường hợp thứ hai là khác nhau. Bằng chứng chấm dứt là giống với một tiêu chuẩn cho $A$ , và nó nên được rõ ràng rằng $B(m,n) \ge A(m,n)$ cho tất cả $m$ và $n$ .

Ở đây chúng tôi tính toán một đại diện đơn phương của

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

Bằng cách tính trực tiếp, $B(B(B(B(0,0),0),0),0)=220$ , vì vậy

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

Lưu ý rằng $A(A(A(A(0,0),0),0),0)$ chỉ là $5$ , vì vậy chúng tôi đã nâng cấp mọi thứ lên một chút tốt để bắt đầu. Tôi không có ý thức rất rõ ràng về việc $B$ phát triển nhanh hơn $A$ bao nhiêu , nhưng xem xét cách tính toán tiến hành, có vẻ như nó sẽ tăng nhanh hơn rất nhiều.

Số chữ số chẵn $A(6,0)$ quá lớn để thể hiện thực tế bằng số thập phân, vì vậy đây là ... khá lớn một cách lố bịch.

Định nghĩa của các số tự nhiên (?), là một chút không chuẩn. Để tiết kiệm không gian, chúng tôi sử dụng (?)cả loại số tự nhiên (ở cấp loại) và loại proxy (ở cấp độ hạn).

Tôi tin rằng một trong hai TypeFamilieshoặc (rõ ràng hơn và khó hiểu hơn) FunctionalDependencieslà cần thiết để có được tính toán cấp độ cần thiết để đạt được các loại thực sự lớn. UndecidableInstanceslà cần thiết để làm việc xung quanh việc kiểm tra chấm dứt rất nguyên thủy của Haskell. Các phần mở rộng khác chỉ cần thiết để nén mã vào không gian có sẵn nhỏ.

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

Một cải tiến nhỏ (tiếng vang nhỏ) trên 5n2 ²⁶²¹⁴⁴ + 5 của xnor . Đây là 99 byte.

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

Làm thế nào nó hoạt động

Chúng ta có

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

và như vậy, với chiều dài gần gấp đôi cho mỗi (:). Biểu thức đã cho o.o.ohoạt động (:).(:).(:).….(:)với 2 · 4 ⁶ · 3 ⁴ = 663552 bản sao của (:).

Haskell với FlexibleContextsvà NoMonomorphismRestriction, (200 · 4 ³³¹⁷⁷⁶ + 75 · 331776 + 16) / 9 2.53 · 10 ¹⁹⁹⁷⁵⁰

Một cải tiến nhỏ so với ^Bubbler 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 - 4 ≈ 1.36 · 10 ¹⁹⁹⁷⁵⁰ , cũng dựa vào các tiện ích mở rộng này. Từ ngữ của loại thách thức cho thấy có thể ổn khi dựa vào chúng (Ví dụ, ví dụ Num [a]và Eq [a]được cho phép, ngay cả khi không có một ví dụ xác định rõ ràng); Tôi không chắc. Đây là 100 byte.

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

Làm thế nào nó hoạt động

Chúng ta có

-(/).(:) :: (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]]]

và như vậy, với chiều dài gần gấp bốn lần cho mỗi (/).(:). Biểu thức đã cho -o.o.ohoạt động -(/).(:).(/).(:).….(/).(:)với 4 ⁶ · 3 ⁴ = 331776 bản sao của (/).(:).

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

Một cải tiến nhỏ khác đối với câu trả lời của Anders 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

Làm thế nào nó hoạt động

(/) -- 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

Chỉ cần thay đổi thành phần chức năng (.)để phân chia phân số (/). Phần Fractional xtrong chữ ký hàm phát nổ cùng với phần chính, cho hệ số nhân không đổi cao hơn một chút.

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 có chữ ký:

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, không cấu hình

Tôi hầu như không thể có được điều này dưới 100 byte, nhưng nó gần đến mức tôi nghĩ rằng tôi có thể đăng nó bằng mọi cách, với hy vọng ai đó phát hiện ra một sự tối ưu hóa.

Đây là phần mở đầu, có giá 93 byte:

#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)

Và biểu thức, 9 byte:

A<9>::T()

Để minh họa:

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

Tăng gấp đôi mỗi khi số lượng tăng lên.

C #, 363

Biểu hiện:

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

Chữ ký loại:

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

Hãy thử trực tuyến!

Đi 1.0 mà không reflect, 98

Các loại đi 1.x được xác định tĩnh. Đây là lần thử đầu tiên của tôi:

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

Trên sân chơi cờ vây :

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

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

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

Đi 1.9 bằng cách sử dụng các bí danh, 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{}

Trên sân chơi cờ vây :

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

Kết quả:

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

Đi 1 bằng reflect, 65532

Có giới hạn trong góireflect về độ dài của tên loại:len(name) <= 1<<16-1

Cho đến nay, tôi đã có thể đạt được tên loại 65532 byte với khối này:

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

Mã đầy đủ trên sân chơi 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,> siêu (siêu (siêu (siêu (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

Giải trình:

Chúng ta đang xác định hàm f, tính toán loại f (0) chỉ là loại đơn vị, trong khi f (S (n)) tính toán cho loại đẳng thức được áp dụng cho chính đối số hàm "được tăng cường" và áp dụng cho n . Dòng cuối cùng về cơ bản là một hàm mong đợi một giá trị của một loại như (27 = (4 = (2 = (1 = ()))))) (cho n = 4).

Ví dụ đơn giản

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

Haskell, 782

Biểu hiện:

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

Chữ ký loại:

:: (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 ¹⁶ )

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

Đây là 49 tuple lồng nhau, với một tuple trống trong cùng. Tên ngắn của loại này thực sự giống với giá trị trong trường hợp này, nhưng tên mở rộng hoàn toàn dài hơn nhiều.

Trình biên dịch Ceylon hoạt động mãi mãi khi cố gắng biên dịch cái này (Trình biên dịch vẫn chạy sau 180 phút) - Tôi sẽ phải thử tính toán độ dài loại lý thuyết.

Vấn đề ở đây là loại một phần tử [X]thực sự được biểu diễn trong hệ thống loại của Ceylon vì Tuple<X, X, []>(tham số đầu tiên là siêu kiểu cho tất cả các loại phần tử, thứ hai là loại phần tử thứ nhất và loại thứ ba của tất cả ngoại trừ phần tử thứ nhất , ở đây là một tuple trống ( emptyđối tượng, thể hiện duy nhất thỏa mãn giao diện Empty)).

Vậy []là empty, [[]]là Tuple<[], [], []>= Tuple<empty, empty, empty>, [[[]]]là Tuple<[[]], [[]], []>= Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []>. Và tên đầy đủ bao gồm tên gói, vì vậy chúng tôi thực sự 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>chỉ có ba cấp độ. Và chúng tôi muốn đi đến 50.

Có độ ceylon.language::emptydài 22 ký tự và mỗi ký tự ceylon.language::Tuple<?,?,ceylon.language::empty>thêm 47 đến hai lần kết quả từ bước trước đó, chúng tôi nhận được f(1) = 22và f(n) = 2 · f(n-1) + 47. Điều này đơn giản hóa f(n) = 69 · 2^(n - 1) - 47và nhập 50 cung cấp cho chúng tôi 38843546786070481. Tất nhiên, điều này lớn hơn nhiều so với những gì sẽ phù hợp với bộ nhớ của máy tính của tôi (8 · 10 ⁹ byte).

Tất nhiên, trình biên dịch có thể thông minh và không cố gắng có toàn bộ tên loại trong bộ nhớ cho đến khi tên của nó được yêu cầu.

Dưới đây là toàn bộ chương trình cố gắng in loại:

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

C # (Trình biên dịch tương tác Visual C #) , 99 byte, Điểm 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))))))))))))))))))))))))

Hãy thử trực tuyến!

Đầu ra

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