도전

가장 긴 형식 서명으로 최대 100 바이트 길이의 표현식을 찾으십시오.

규칙

• 형식 유추가있는 정적으로 유형이 지정된 언어가 허용됩니다.
• 유형은 모호하지 않아야하지만 정의 된 인스턴스가없는 유형을 포함 할 수 있습니다. 예를 들어 Num [a]및Eq [a] 심지어 정의 예를하지 않고, 사용할 수 있습니다
• STDIN / STDOUT으로 프로그램을 컴파일하는 데 필요한 최소값 이외의 가져 오기는 없습니다.
• 무한 타입은 허용되지 않습니다
• 답변에 둘 이상의 표현이있는 경우 하나만 점수에 기여할 수 있습니다. 예를 들어, 컴포지션의 형식 서명이 (.) :: (b -> c) -> (a -> b) -> a -> c점수가 20이지만, 사본이 25 개인 답변 (.)\n의 점수는 500이 아닌 20입니다.
• 표현식은 최대 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)]

하스켈, ~ 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))))

각 줄의 응용 프로그램의 수를 quadraples f주는 4^9 = 2^18말. 따라서 형식 서명의 크기는의 순서입니다 2^(2^18).

자바, 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.

Ørjan Johansen은 자연수 생성자를 삽입하고 인수를 조금 다르게 저장하여 2 바이트를 절약하여 다른 반복을위한 충분한 공간을 제공한다는 사실을 깨달은 Ørjan Johansen에게 많은 감사를드립니다 #.

분명히 타입 체커는이 프로그램을 검사하려고 포기할 것입니다. 서명이 어떻게 보이는지에 대한 일반적인 의미를 얻으려면 (관찰 가능한 우주에 적합 할 정도로 작은 경우) 훨씬 더 작은 것을 시도하십시오

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

설명

#유형 제품군은 밀접하게 관련되어 ACKERMANN - 피터 기능 , 일반적으로 작성 $A$ 하지만, #상당히 빠르게 성장한다. Ackermann–Péter 기능이 정의되었습니다

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

$A(m,0)=A(m-1,1)$m > 0 인 경우 A ( m , 0 ) = A ( m - 1 , 1 )$m > 0$

$A(m,n)=A(m-1, A(m, n-1))$m , n > 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 , 0 ) = B ( m - 1 , m )$m > 0$

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

두 번째 경우 만 다릅니다. 종료 증명은 $A$ 의 표준과 동일 하며 모든 m 과 n에 대해 $B(m,n) \ge A(m,n)$ 임을 분명히해야합니다 .$m$$n$

여기서 우리는 단항 표현을 계산합니다.

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

참고 ( ( ( ( 0 , 0 ) , 0 ) , 0 ) , 0 ) 아니라 5 우리가 시작하기 좋은 비트까지 일을 충돌했습니다, 그래서. 나는 B 가 A 보다 얼마나 빨리 자라는 지에 대한 명확한 의미가 없습니다 .$A(A(A(A(0,0),0),0),0)$$5$$B$$A$ 계산이 진행되는 방식을 고려할 때 상당히 빠르게 성장할 것으로 보입니다.

짝수 A 의 자릿수 ( 6 , 0 )$A(6,0)$ 실제로 십진수로 표현하기에는 너무 크므로 이것은 엄청나게 큽니다.

자연수의 정의는 (?)약간 비표준입니다. 공간을 절약하기 위해 (?)자연수 유형 (유형 레벨)과 프록시 유형 (용어 레벨)으로 사용합니다.

나는 정말로 큰 유형에 도달하는 데 필요한 유형 수준 계산을 얻으려면 하나 TypeFamilies이상 (더 자세하고 난독하게) FunctionalDependencies이 필요 하다고 생각합니다 . UndecidableInstancesHaskell의 매우 기본적인 종료 검사 문제를 해결하는 데 필요합니다. 다른 확장은 코드를 사용 가능한 작은 공간으로 압축하는 데만 필요합니다.

하스켈, 9 · 2 ^663552-3 (≈ 1.02 · 10 ¹⁹⁹⁷⁵⁰ )

xnor의 5⋅2 ²⁶²¹⁴⁴ + 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 ⁴ = 663552의(:) .

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

Bubbler의 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 − 4 ≈ 1.36 · 10 ^199750에 비해 약간의 개선이 이루어 ^졌으며 , 이러한 확장에도 의존합니다. 의 도전 종류의 문구가 그들에 의존 괜찮을 수도 있습니다 제안 ( "예를 들어 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]]]

길이는 각각 대략 4 배가됩니다 (/).(:). 주어진 표현 -o.o.o은의 -(/).(:).(/).(:).….(/).(:)4 ⁶ · 3 ⁴ = 331776 사본으로 해결 (/).(:)됩니다.

하스켈, 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552-4

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

작동 원리

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

온라인으로 사용해보십시오!

reflect, 98 없이 1.0 간다

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

이드리스,> 하이퍼 (하이퍼 (하이퍼 (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에 적용된 f를 계산합니다. . 마지막 줄은 기본적으로 (27 = (4 = (2 = (1 = ())))))와 같은 유형의 값을 기대하는 함수입니다 (n = 4의 경우).

간단한 예

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

하스켈, 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

실론, 38843546786070481 (~ 4 · 10 ¹⁶ )

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

이것은 빈 튜플이 가장 안쪽에있는 49 개의 중첩 된 단일 튜플입니다. 이 유형의 짧은 이름은 실제로이 경우의 값과 동일하지만 완전히 확장 된 이름은 훨씬 더 깁니다.

Ceylon 컴파일러는 이것을 컴파일 할 때 영원히 작동합니다 (컴파일러는 여전히 180 분 후에 실행 중임) – 이론적 유형 길이를 계산해야합니다.

여기서 문제는 단일 요소 튜플 유형입니다. [X] 이 실제로 실론 유형 시스템에서 Tuple<X, X, []>(첫 번째 매개 변수는 모든 요소 유형의 수퍼 유형이고, 두 번째는 첫 번째 요소의 유형이며, 세 번째는 첫 번째 요소를 제외한 모든 유형의 유형으로 표시됨) 여기에 빈 튜플 ( 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::empty22 자이며, 각각의 ceylon.language::Tuple<?,?,ceylon.language::empty>이전 단계에서 두 번 결과에 47을 추가, 우리는 도착f(1) = 22 하고 f(n) = 2 · f(n-1) + 47. 이것은을 단순화하고 f(n) = 69 · 2^(n - 1) - 4750을 입력하면 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 Compiler) , 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]]]]]]]]]]]]]]]]]]]]]]]]