Сделайте длинную подпись типа


23

Вызов

Найдите выражение длиной не более 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
Я подозреваю, что язык с зависимой типизацией может сделать сигнатуру типа длиной любого числа, которое можно вычислить.
xnor

@xnor Поскольку системы типов сами по себе могут быть завершены ( stackoverflow.com/a/4047732/5154287 ), я полагаю, что это становится более трудной проблемой бобра. Должен ли я редактировать теги?
Майкл Кляйн

Ответы:


19

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


2
Классический подход, но я думаю, что параметры могут быть лучше настроены. В частности, я думаю, что f x=(x,x,x)за счет одного n.в последней строке дает оптимальный результат для этой общей структуры.
Питер Тейлор

Я не знаю Хаскелла, так что я мог бы быть здесь вне базы, но я укажу, что 4 ^ (4 ^ 4) меньше, чем 3 ^ (4 ^ 5)
Sparr

Уверен, 4-й n.будет больше. 2^18против, 3 * (2^16)если я не ошибся при расчете первоначального возведения в степень: 2^(4^9)против3^((4^8)*3)
Draco18s

Нет, @PeterTaylor правильно: 2 ^ (4 ^ 9) = 16 ^ (4 ^ 8) <27 ^ (4 ^ 8) = 3 ^ (4 ^ 8 ⋅ 3).
Андерс Касеорг

(,)(или (,,)) может быть использован для сохранения некоторых байтов и улучшения оценки, используя больше ns.
მოიმო

11

Ява, оценка 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)))))))))))))))))))

Подпись типа времени компиляции этого должна соответствовать этому.


хмм. поскольку лямбды разрешены, это, вероятно, получит более высокий балл
только ASCII

10

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.

Огромное спасибо Орджану Йохансену, который понял, что создание инфиксного конструктора натуральных чисел и построение аргументов немного по-другому сэкономили два байта, оставив достаточно места для еще одной итерации #.

Очевидно, что средство проверки типов перестанет пытаться проверить эту программу. Чтобы получить общее представление о том, как будет выглядеть подпись (если она достаточно мала, чтобы поместиться в наблюдаемую вселенную), попробуйте гораздо меньшую

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

объяснение

Семейство #типов тесно связано с функцией Аккермана – Петера , обычно пишется как , но растет значительно быстрее. Определена функция Аккермана – ПетераA#

A(0,n)=n+1

A(м,0)знак равноA(м-1,1) когдам>0

A(м,N)знак равноA(м-1,A(м,N-1)) когдам,N>0

#с другой стороны, мы можем позвонить и написатьВ

В(0,N)знак равноN+1

В(м,0)знак равноВ(м-1,м)m > 0 когдам>0

В(м,N)знак равноВ(м-1,В(м,N-1))m , n > 0 когдам,N>0

Только второй случай отличается. Доказательство завершения идентично стандартному для , и должно быть ясно, что для всех и .AВ(м,N)A(м,N)мN

Здесь мы вычисляем унарное представление

рзнак равноВ(В(В(В(В(В(В(В(0,0),0),0),0),0),0),0),0)

По прямому расчету , т.В(В(В(В(0,0),0),0),0)знак равно220

рзнак равноВ(В(В(В(220,0),0),0),0) .

Обратите внимание, что - только , поэтому мы неплохо поднялись, чтобы начать. У меня нет четкого представления о том, насколько быстрее растет чем , но, учитывая ход вычислений, похоже, что он будет расти гораздо быстрее.A(A(A(A(0,0),0),0),0)5ВA

Количество цифр в четном слишком велико, чтобы выразить его практически в десятичном виде, так что это ... довольно смехотворно большое.A(6,0)

Определение натуральных чисел (?)немного нестандартно. Для экономии места мы используем (?)как натуральный тип числа (на уровне типа), так и тип прокси (на уровне термина).

Я считаю, что либо TypeFamiliesили (более многословно и запутанно) FunctionalDependenciesнеобходимо, чтобы получить вычисления на уровне типов, необходимые для достижения действительно больших типов. UndecidableInstancesнеобходимо обойти очень примитивную проверку завершения Haskell. Другие расширения нужны только для сжатия кода в небольшое доступное пространство.



@ ØrjanJohansen, лучше ли складывать Zспереди, чем начинать S(S Z)#S Z, или то же самое?
dfeuer

В любом случае, дополнительное #Zв конце приветствуется.
dfeuer

1
Это то же самое значение, но сохраняет один байт, а изменение типа данных ?сохраняет другой, оставляя место для дополнительного #Z.
Орджан Йохансен

1
В то время как вы впервые редактировали, я обнаружил, что A(m,1)никогда не был больше A(A(m,0),0), и собирался сделать замечание, но тогда вы просто оптимизировали до такой степени, что варианты были равны. (Также m+1никогда не бывает больше A(m,0).)
Орджан Йохансен

9

Haskell, 9 · 2 663552 - 3 (≈ 1,02 · 10 199750 )

Небольшое («маленькое») улучшение по сравнению с xnor's 5⋅2 262144 + 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 6 · 3 4 = 663552 копий (:).

Haskell с FlexibleContextsи NoMonomorphismRestriction, (200 · 4 331776 + 75 · 331776 + 16) / 9 ≈ 2,53 · 10 199750

Небольшое улучшение по сравнению с Bubbler 12 · 2 663552 + 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]]]

и так далее, с длиной примерно в четыре раза для каждого (/).(:). Данное выражение -o.o.oработает -(/).(:).(/).(:).….(/).(:)с 4 6 · 3 4 = 331776 копий (/).(:).


7

Haskell, 12 · 2 663552 + 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Часть в функции подписи взрывается вместе с основной частью, давая немного более высокий постоянный множитель.


6

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

1
979 33554438 58640620148060 это похоже на какую-то нелепую запись OEIS. возможно, самые большие изменения в величине, которые я когда-либо видел в уточняемой записи PPCG.
Спарр


5

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 ++, в которых classвместо этого использовалось ключевое слово typename. Интересно, есть ли где-нибудь компилятор, который все еще поддерживает эту фразу для обратной совместимости?

4

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

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

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


Примечания: x:=никогда не считается.


недействительный, reflectимпорт должен быть посчитан
только ASCII




1

Идрис,> гипер (гипер (гипер (гипер (гипер (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 = ()))))

1
Я не очень знаю , Идриса, но я думаю , что это может произойти сбой по техническим причинам : Вы должны увеличить длину сигнатуры типа выражения, не длина его значения. Разве подпись типа вашего окончательного выражения не является просто :Type?
Орджан Йохансен

Что вы подразумеваете под неисчислимым числом ? Я не знаком с hyper; могли бы вы объяснить?
dfeuer

@ ØrjanJohansen О да, просто исправил это и применил еще несколько изменений
Mega Man

1
(0) Объяснение кажется немного запаздывающим. (1) Теперь это всего 98 байт. (2) Так как первый аргумент hyperвыражается значительно сильнее, чем остальные, я думаю, вы хотите, чтобы все / большинство из них 99были 9s. (3) Если предположить, что $работы Идриса, такие как у Хаскелла, внешний набор скобок после f$является излишним. (4) Не могли бы вы сократить hyperили это потребует подписи типа?
Орджан Йохансен


0

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

Становится 1814 персонажами с ghc 8.0.2, так как тип sumтогда(Num a, Foldable t) => t a -> a
Матье CAROFF

0

Цейлон, 38843546786070481 (~ 4 · 10 16 )

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

Это 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 9 байт).

Конечно, компилятор может быть умным и не пытаться хранить полное имя типа в памяти, пока не будет запрошено его имя.

Вот полная программа, пытающаяся напечатать тип:

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

0

C # (интерактивный компилятор Visual C #) , 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]]]]]]]]]]]]]]]]]]]]]]]]
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.