Виклик

Знайдіть вираз довжиною не більше 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)]

Хаскелл, ~ 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).

Ява, оцінка 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, який зрозумів, що вбудований конструктор натуральних чисел і побудова аргументів трохи інакше врятував два байти, що створило достатньо місця для чергової ітерації # .

Очевидно, що перевірка типу відмовиться від спроб перевірити цю програму. Щоб отримати загальне уявлення про те, як виглядатиме підпис (якби він був досить маленьким, щоб вміститись у спостережуваний Всесвіт), спробуйте набагато менші

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

Пояснення

#Сімейного типу тісно пов'язана з функцією Ackermann-Петера , зазвичай пишеться $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$ .

Тут ми обчислюємо одинарне подання

$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або більш (багатослівні та затуманені) FunctionalDependencies. UndecidableInstancesпотрібен для вирішення дуже примітивної перевірки припинення Haskell. Інші розширення потрібні лише для стиснення коду в невеликий доступний простір.

Хаскелл, 9 · 2 ⁶⁶³⁵⁵² - 3 (≈ 1,02 · 10 ¹⁹⁹⁷⁵⁰ )

Невелике ("невелике") покращення порівняно з xnor's 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 з FlexibleContextsі NoMonomorphismRestriction, (200 · 4 ³³¹⁷⁷⁶ + 75 · 331776 + 16) / 9 ≈ 2,53 · 10 ¹⁹⁹⁷⁵⁰

Невелике поліпшення порівняно з Bubbler's 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 ⁴ = 331776 копій (/).(:).

Хаскелл, 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 - 4

Ще одне невелике поліпшення Андерса Касеорга .

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Частина в функції підпису вибухає разом з основною частиною, даючи трохи вищий постійний множник.

С, 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 без reflect, 98

Типи Go 1.x є статично визначеними. Ось моя перша спроба:

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

На майданчику Go :

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

На майданчику Go :

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, використовуючи reflect65532

В упаковці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)) обчислює тип рівності, застосований до аргументу функції, "завищений" сам по собі і f, застосований до n . Останній рядок - це функція, яка очікує значення типу типу (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 вкладених одних кортежів із порожнім кордоном. Коротке ім’я цього типу насправді те саме, що значення в цьому випадку, але повністю розширене ім'я набагато довше.

Під час спроби компіляції цей компілятор Цейлон працює вічно (компілятор все ще працював через 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::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 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]]]]]]]]]]]]]]]]]]]]]]]]