Meydan okuma

En uzun türden imzayla, en fazla 100 bayt uzunluğunda bir ifade bulun.

kurallar

• Tür çıkarımı olan statik olarak yazılmış herhangi bir dile
• Tür belirsiz olmalıdır, ancak aksi takdirde tanımlanmış örnekleri olmayan türleri içerebilir. Örneğin Num [a]ve Eq [a]tanımlanmış bir örnek olmadan bile izin verilir
• STDIN / STDOUT olan bir programı derlemek için gerekenlerden başka ithalat yapılmaz
• Sonsuz tiplere izin verilmez
• Bir cevabın birden fazla ifadesi varsa, sadece bir tanesi skora katkıda bulunabilir. Örneğin, kompozisyonun tip imzası (.) :: (b -> c) -> (a -> b) -> a -> c20 olmasına rağmen, 25 kopyaya sahip olan cevap (.)\n500 değil 20 olacaktı.
• İfade en çok 100 bayt olmalı
• Skor, işlevin adı ve herhangi bir beyaz boşluk hariç, imza türü içindeki karakter sayısıdır. Örneğin, f :: (a -> b) -> a -> b12 puan olurdu
• En yüksek puan kazanır!

Örnekler

Diğer dillere izin verilmesine rağmen, aşağıdaki örnekler Haskell'de:

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

Her uygulama fkabaca tip imzasını dönüştürerek tipi imzasını katına Tkadar (T,T). Örneğin, dört katlı kompozisyonun f.f.f.f$0türü vardır

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

Her satır uygulamalarının sayısını quadraples fvererek 4^9 = 2^18sonunda. Bu nedenle, imza türünün sırası büyüklüğüne sahiptir 2^(2^18).

Java, skor 17301488

<T>java.util.Map<T,T>f(T t){return null;}100 bayt sınırına doğru sayılan yöntemi gerektirir .

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

Bunun derleme zamanı türü imzası bununla eşleşmelidir .

Uzantılı 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)

Çevrimiçi deneyin!

Gerektirir -XDataKinds, -XPolyKinds, -XTypeOperators, -XUndecidableInstances, ve -XTypeFamilies.

Doğal sayı yapıcısını birbirine karıştırmanın ve argümanları biraz farklı bir şekilde oluşturmanın iki bayttan tasarruf sağladığını fark eden Ørjan Johansen'e çok teşekkürler #.

Açıkçası, tür denetleyicisi bu programı denetlemeye çalışırken vazgeçecek. İmzanın nasıl görüneceğine dair genel bir fikir edinmek için (gözlemlenebilir evrene sığacak kadar küçük olsaydı), daha küçük olanı deneyin.

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

açıklama

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

Burada biz tek bir temsili hesaplamak

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

Doğal sayıların tanımı, (?)biraz standart dışıdır. Yer kazanmak için (?)hem doğal sayı tipi (tür düzeyinde) hem de vekil türü (terim düzeyinde) olarak kullanıyoruz.

Gerçekten büyük tiplere ulaşmak için gereken tip-seviyeli hesaplamayı elde etmek için ya TypeFamiliesda (daha ayrıntılı ve karışık) birinin FunctionalDependenciesgerekli olduğuna inanıyorum . UndecidableInstancesHaskell'in çok ilkel sonlandırma kontrolü etrafında çalışmak için gereklidir. Diğer uzantılar sadece kodu küçük boş alana sıkıştırmak için gereklidir.

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

Xnor'ın 5⋅2 ²⁶²¹⁴⁴ + 5 değerinde küçük (“küçük”) bir gelişme . Bu 99 bayttır.

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

Nasıl çalışır

Sahibiz

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

ve diğerleri için uzunluğu kabaca iki katına çıkacak şekilde (:). Verilen ifade o.o.oortaya eserler (:).(:).(:).….(:)4 · 2 ile ⁶ 3 · ⁴ arasında = 663.552 kopya (:).

Haskell FlexibleContextsve NoMonomorphismRestriction(200 · 4 ^331.776 + 75 · + 16 331776) / 9 ≈ 2.53 · 10 ^199.750

Üzerinde küçük bir iyileşme Bubbler en 12 · 2 ^663.552 + 9 · 663552-4 ≈ 1.36 · 10 ¹⁹⁹⁷⁵⁰ , ayrıca bu uzantılara dayanır. Mücadele türünün ifadesi, onlara güvenmenin uygun olamayacağını öne sürüyor (“Örneğin Num [a]ve Eq [a]tanımlanmış bir örnek olmadan bile izin veriliyor”); Emin değilim. Bu 100 bayttır.

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

Nasıl çalışır

Sahibiz

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

ve diğerleri için uzunluğu kabaca dört katına çıkacak şekilde (/).(:). Verilen ifade -o.o.oortaya eserler -(/).(:).(/).(:).….(/).(:)ile 4 ⁶ · 3 ⁴ = 331.776 kopya arasında (/).(:).

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

Anders Kaseorg'un cevabında bir başka küçük gelişme .

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

Nasıl çalışır

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

Sadece fonksiyon kompozisyonunu (.)kesirli bölüme değiştirdim (/). Fractional xBiraz daha yüksek sabit çarpanı veren ana kesimiyle birlikte işlev imzası patlar, part.

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 imzası vardır:

int(*)(int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,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, rekabetçi olmayan

Ben zar zor 100 bayt altına almazsak, ancak çok yakın birisinin bir optimizasyon görür ben umuduyla yine de ilan edebilirler anladı.

Bu 93 bayt mal olan prolog.

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

Ve ifade, 9 bayt:

A<9>::T()

Göstermek için:

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

Sayı her arttığında kabaca iki katına çıkar.

C #, 363

İfade:

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

İmza yazın:

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

Çevrimiçi deneyin!

1.0'a git reflect, 98

Go 1.x tipleri statik olarak tanımlanmıştır. İşte benim ilk denemem:

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

Go oyun alanında :

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

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

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

Tür takma adları kullanarak 1.9 kullan, 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 oyun alanında :

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

Sonuç:

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

Go 1 kullanarak reflect, 65532

Tip adının uzunluğu paketinde bir sınırreflect vardır :len(name) <= 1<<16-1

Bu blokta şu ana kadar 65532 byte türüne ulaşabildim:

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

Go oyun alanında tam kod :

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

İdris,> hiper (hiper (hiper (hiper (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

Açıklama:

Bir fonksiyon tanımlıyoruz, f (0) tipini sadece birim tipinde hesaplarken f (S (n)), kendi başına "hypered" fonksiyon değişkenine uygulanan eşitlik tipine ve . Son satır, temelde (27 = (4 = (2 = (1 = ()))))) () için (n = 4) türünde bir değer bekleyen bir işlevdir.

Basit bir örnek

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

Haskell, 782

İfade:

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

İmza yazın:

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

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

Bu, en içinde boş bir demet olan, 49 yuvalanmış bir tekerdir. Bu türdeki kısa ad aslında bu durumdaki değerle aynıdır, ancak tamamen genişletilmiş ad çok daha uzundur.

Bunu derlemeye çalışırken Ceylon derleyicisi sonsuza dek çalışıyor (Derleyici hala 180 dakika sonra çalışıyordu) - Teorik tip uzunluğunu hesaplamayı denemem gerekecek.

Buradaki problem, bir element-tuple türünün Ceylon'un tip [X]sisteminde gerçekte Tuple<X, X, []>(ilk parametre tüm eleman tipleri için bir süper tip, ikincisi, birinci elemanın tipi ve üçüncüsü, ilk elemanlar dışındaki tüm tiplerin) temsil edilmesidir. Burada boş bir tuple ( emptynesne, arayüzü sağlayan tek örnek Empty).

Yani []ise empty, [[]]olduğu Tuple<[], [], []>= Tuple<empty, empty, empty>, [[[]]]olduğu Tuple<[[]], [[]], []>= Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []>. Ve tam ad paket adlarını içeriyor, bu yüzden aslında 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>sadece üç seviye var. Ve 50'ye gitmek istiyoruz.

ceylon.language::empty22 karakter uzunluğunda olduğu gibi , her biri ceylon.language::Tuple<?,?,ceylon.language::empty>önceki adımın sonucunu 47 ila iki katına çıkarır, anlıyoruz f(1) = 22ve f(n) = 2 · f(n-1) + 47. Bu, basitleştirmek f(n) = 69 · 2^(n - 1) - 47ve 50'ye girmek bize 38843546786070481 verir. Tabii ki, bu bilgisayarımın belleğine sığacak olandan çok daha büyük (8 · 10 ⁹ bayt).

Tabi ki, derleyici akıllı olabilir ve adı istenene kadar bütün tip ismini hafızasında tutmaya çalışamaz.

Türü yazdırmaya çalışan tam program:

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

C # (Visual C # Etkileşimli Derleyici) , 99 bayt, Puan 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))))))))))))))))))))))))

Çevrimiçi deneyin!

çıktılar

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