একটি দীর্ঘ টাইপ স্বাক্ষর করুন

Question

চ্যালেঞ্জ

সবচেয়ে দীর্ঘতম স্বাক্ষর সহ কমপক্ষে 100 বাইট দীর্ঘ, একটি অভিব্যক্তি সন্ধান করুন।

বিধি

• টাইপ অনুমান সহ স্ট্যাটিক্যালি টাইপ করা যে কোনও ভাষা অনুমোদিত
• প্রকারটি অবশ্যই দ্ব্যর্থহীন, তবে অন্যথায় সংজ্ঞায়িত দৃষ্টান্ত ছাড়াই প্রকারের অন্তর্ভুক্ত থাকতে পারে। উদাহরণস্বরূপ Num [a]এবং Eq [a]অনুমোদিত, এমনকি কোনও সংজ্ঞায়িত উদাহরণ ছাড়াই
• STDIN / STDOUT সহ কোনও প্রোগ্রাম সংকলনের জন্য প্রয়োজনীয় ন্যূনতম ব্যতীত অন্য কোনও আমদানি নেই
• অসীম ধরণের অনুমতি নেই
• যদি উত্তরের একাধিক এক্সপ্রেশন থাকে তবে কেবলমাত্র একজনই স্কোরটিতে অবদান রাখতে পারে। উদাহরণস্বরূপ, রচনাটির ধরণের স্বাক্ষরটি যদিও (.) :: (b -> c) -> (a -> b) -> a -> c, 20 এর স্কোর, 25 টি অনুলিপি সহ উত্তরটি (.)\n20 এর স্কোর হবে, 500 নয়
• অভিব্যক্তিটি অবশ্যই সর্বাধিক, 100 বাইট হতে হবে
• স্কোরটি ফাংশনের নাম এবং কোনও সাদা স্থান বাদ দিয়ে টাইপ স্বাক্ষরের অক্ষরের সংখ্যা। উদাহরণস্বরূপ, f :: (a -> b) -> a -> b12 এর স্কোর হবে
• সর্বোচ্চ স্কোর জয়!

উদাহরণ

অন্য ভাষাগুলির অনুমতি থাকলেও নিম্নলিখিত উদাহরণগুলি হ্যাসকেলে রয়েছে:

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

Comments

সম্পর্কিত । আমি ভেবেছিলাম এখানে প্রায় সঠিক ডুপ ছিল, কিন্তু আমি এটি পাইনি।

— পিটার টেইলর

আমার সন্দেহ হয় যে নির্ভরশীল টাইপিংয়ের সাথে কোনও ভাষা গণনা করতে পারে এমন সংখ্যার দৈর্ঘ্যের একটি স্বাক্ষর তৈরি করতে পারে।

— xnor

@xnor টাইপ সিস্টেম হিসাবে নিজেদের সম্পূর্ণ হয়েছে (টুরিং হতে পারে stackoverflow.com/a/4047732/5154287 ), আমি এটি একটি ব্যস্ত বীবর সমস্যা আরো তখন হয়ে অনুমান। আমি ট্যাগগুলি সম্পাদনা করা উচিত?

— মাইকেল ক্লেইন

Answer 1

হাস্কেল, ~ 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)।

Comments

ক্লাসিক পদ্ধতির, তবে আমি মনে করি প্যারামিটারগুলি আরও ভালভাবে সুর করা যেতে পারে। বিশেষত, আমি মনে করি যে শেষ লাইনে f x=(x,x,x)একটি ব্যয়ে n.এই সামগ্রিক কাঠামোর জন্য সর্বোত্তম স্কোর দেয়।

— পিটার টেইলর

আমি হাস্কেলকে চিনি না, সুতরাং আমি এখানে বেস থেকে যেতে পারব, তবে আমি উল্লেখ করব যে 4 ^ (4 ^ 4) 3 than (4 ^ 5) এর চেয়ে কম

— স্পার

খুব নিশ্চিত যে 4 র্থ n.বৃহত্তর হতে চলেছে। 2^18বনাম 3 * (2^16)যতক্ষণ না আমি আসল 2^(4^9)3^((4^8)*3)

— ক্ষয়ক্ষেত্র

না, @ পিটারটেলর সঠিক: 2 ^ (4 ^ 9) = 16 ^ (4 ^ 8) <27 ^ (4 ^ 8) = 3 ^ (4 ^ 8 ⋅ 3)।

— অ্যান্ডারস ক্যাসরগ

(,)(বা (,,)) কিছু বাইট সংরক্ষণ এবং আরও nগুলি ব্যবহার করে স্কোর উন্নত করতে ব্যবহার করা যেতে পারে ।

— 29

Answer 2

জাভা, স্কোর 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)))))))))))))))))))

এর সংকলন-টাইপ স্বাক্ষরের সাথে এটি মিলবে ।

Comments

হুম। যেহেতু ল্যাম্বডাসের অনুমতি রয়েছে এটি সম্ভবত উচ্চতর স্কোর অর্জন করবে

— এএসসিআইআই-কেবল

Answer 3

এক্সটেনশনগুলির সাথে হাস্কেল , $\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।

আরজান জোহানসেনকে অনেক ধন্যবাদ, যিনি বুঝতে পেরেছিলেন যে প্রাকৃতিক সংখ্যা নির্মাতা ইনফিক্স তৈরি করে এবং যুক্তিগুলি কিছুটা আলাদাভাবে তৈরি করে দুটি বাইট সংরক্ষণ করেছিল, এর অন্য পুনরাবৃত্তির জন্য পর্যাপ্ত জায়গা তৈরি করেছে #।

স্পষ্টতই, টাইপ চেকার এই প্রোগ্রামটি চেক করার চেষ্টা ছেড়ে দিবে। স্বাক্ষরটি দেখতে কেমন তা সম্পর্কে সাধারণ ধারণা পেতে (এটি যদি পর্যবেক্ষণযোগ্য মহাবিশ্বে ফিট করার পক্ষে যথেষ্ট ছোট ছিল) তবে আরও ছোট চেষ্টা করুন

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$ , সুতরাং আমরা জিনিসগুলি শুরু করার জন্য খুব ভালভাবে ধাক্কা দিয়েছি। A এর চেয়ে $B$ কত দ্রুত বৃদ্ধি পায় তার খুব স্পষ্ট ধারণা আমার কাছে নেই , তবে গণনাটি কীভাবে এগিয়ে চলেছে তা বিবেচনা করে মনে হয় এটি বেশ দ্রুত গতিতে বাড়তে পারে।$A$

এমনকি $A(6,0)$ এর অঙ্কের সংখ্যা দশমিকভাবে কার্যত প্রকাশ করার জন্য খুব বড়, সুতরাং এটি ... বরং হাস্যকরভাবে বড়।

প্রাকৃতিক সংখ্যার সংজ্ঞা (?), কিছুটা মানহীন। স্থান বাঁচাতে, আমরা (?)একটি প্রাকৃতিক সংখ্যা টাইপ (প্রকারের স্তরে) এবং প্রক্সি টাইপ (শব্দ স্তরে) উভয় হিসাবে ব্যবহার করি ।

আমি বিশ্বাস করি যে সত্যই বড় ধরণের কাছে পৌঁছানোর জন্য টাইপ-লেভেল গণনা পাওয়ার জন্য যে কোনও TypeFamiliesবা (আরও শব্দবাচক এবং অবহেলিতভাবে) FunctionalDependenciesপ্রয়োজনীয়। UndecidableInstancesহাস্কেলের খুব আদিম সমাপ্তি পরীক্ষার আশেপাশে কাজ করা দরকার। অন্যান্য এক্সটেনশানগুলি কেবলমাত্র ছোট উপলভ্য জায়গায় কোডটি সংকুচিত করতে প্রয়োজন।

Comments

আরও একটি#Z

— janrjan জোহানসেন

@ আরজান জোহেনসেন, কী Zআরম্ভের চেয়ে সামনের দিকে স্ট্যাক করে রাখছেন S(S Z)#S Z?

— dfeuer

যেভাবেই হোক, শেষে অতিরিক্তটি #Zসর্বাধিক স্বাগত।

— dfeuer

এটি হুবহু একই মান তবে একটি বাইট ?সংরক্ষণ করে এবং ডাটাটাইপটি অন্যটিকে সংরক্ষণ করে পরিবর্তন করে অতিরিক্ত বাড়িয়ে #Z।

— আরজান জোহানসেন

আপনি প্রথম সম্পাদনা করার সময়, আমি আবিষ্কার করেছি যে এর A(m,1)চেয়ে বড় কখনও ছিল না A(A(m,0),0)এবং এটি সম্পর্কে মন্তব্য করতে চলেছিল, তবে আপনি কেবল সেই বিন্দুতে অনুকূলিত হন যেখানে বিকল্পগুলি সমান ছিল। (এর m+1চেয়ে বড় কখনও হয় না A(m,0)))

— Øর্জন জোহানসেন

Answer 4

হাস্কেল, 9 · 2 ⁶⁶³⁵⁵² - 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 কপি (:)।

হাস্কেল FlexibleContextsএবং এর সাথে NoMonomorphismRestriction, (200 · 4 ³³¹⁷⁷⁶ + 75 · 331776 + 16) / 9 ≈ 2.53 · 10 ¹⁹⁹⁷⁵⁰

^{বুবলারের} 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 কপি (/).(:)।

Answer 5

হাস্কেল, 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প্রধান অংশ সহ ফাংশন স্বাক্ষর বিস্ফোরণ, সামান্য উচ্চ ধ্রুবক গুণক দান অংশগ্রহণ।

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

Comments

979 33554438 58640620148060 এটি কিছু হাস্যকর OEIS প্রবেশের মতো দেখাচ্ছে। সম্ভবত আমি কোনও পিপিসি এন্ট্রি পরিমার্জনিত হতে দেখেছি মাত্রার বৃহত্তম পরিবর্তনগুলি।

— স্পার

@ স্পার আপনি

— বিড়াল

Answer 7

সি ++ 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>)

মোটামুটি দ্বিগুণ হওয়ায় প্রতিবারের সংখ্যা বেড়ে যায়।

Comments

আমার মনে হচ্ছে সি -++ এর কিছু প্রাচীন (প্রাক-মান?) সংস্করণ ছিল যা মূলশব্দটি ব্যবহার করেছিল class বদলে typename। আমি অবাক হই যে যদি কোথাও একটি সংকলক আছে যা এখনও পিছনের সামঞ্জস্যের জন্য সেই বাক্যটিকে সমর্থন করে?

Answer 8

সি #, 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]]]]]]]]]]]]]]

এটি অনলাইন চেষ্টা করুন!

Answer 9

reflect98 ছাড়াই 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)
}

টাইপ এলিয়াস, 2389 ব্যবহার করে 1.9 এ যান

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

গো খেলার মাঠে পুরো কোড :

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:=কখনই গণনা করা হয় না।

Comments

অবৈধ, reflectআমদানি গণনা করা দরকার

— এএসসিআইআই-কেবল

3403?

— ASCII- কেবল

3685

— ASCII কেবল

65535

— ASCII- কেবলমাত্র

Answer 10

ইদ্রিস,> হাইপার (হাইপার (হাইপার (হাইপার (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

ব্যাখ্যা:

আমরা একটি ফাংশন সংজ্ঞায়িত করছি, এফ (0) টাইপকে কেবল একক প্রকারের গণনা করা হয়, যখন চ (এস (এন)) নিজেই "হাইপারড" ফাংশন আর্গুমেন্টে প্রয়োগ করা সমতা প্রকারের গণনা করে এবং n এ প্রয়োগ করা হয় । শেষ লাইনটি মূলত (27 = (4 = (2 = (1 = (1) ()))))) (এন = 4 এর জন্য) এমন ধরণের মান আশা করে এমন একটি ফাংশন।

সাধারণ উদাহরণ

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

Comments

আমি ইদ্রিসকে সত্যই জানি না , তবে আমি মনে করি এটি কোনও প্রযুক্তিগত ক্ষেত্রে ব্যর্থ হতে পারে: আপনার অভিব্যক্তির ধরণের স্বাক্ষরের দৈর্ঘ্যটি নয়, এর মানের দৈর্ঘ্য নয় max আপনার চূড়ান্ত প্রকাশের ধরণের স্বাক্ষরটি কি ঠিক নয় :Type?

— আর্জন জোহানসেন

একটি অপ্রয়োজনীয় সংখ্যা বলতে কী বোঝ ? আমি এর সাথে পরিচিত নই hyper; আপনি ব্যাখ্যা করতে পারেন?

— ডিফিউয়ার

@ আরজান জোহানসেন ওহ হ্যাঁ, ঠিক এটি ঠিক করেছেন এবং আরও কয়েকটি পরিবর্তন প্রয়োগ করেছেন

— মেগা ম্যান

(0) ব্যাখ্যা কিছুটা পিছিয়ে আছে বলে মনে হচ্ছে। (1) এটি এখন 98 বাইট মাত্র। (২) যেহেতু প্রথম যুক্তিটি hyperবাকিগুলির চেয়ে প্রসারিতভাবে প্রসারিত হয়, আমি মনে করি আপনি তাদের / বেশিরভাগেরই 99এস হতে চান 9। (৩) ইদ্রিসের $কাজ হাস্কেলের মতো অনুমান করা , পরের বন্ধনীর বাহ্যিক সেটটি f$অপ্রয়োজনীয়। (4) আপনি সংক্ষিপ্ত করতে পারেন hyperবা তার জন্য নিজেই কোনও ধরণের স্বাক্ষর প্রয়োজন?

— আরজান জোহানসেন

@dfeuer en.wikipedia.org/wiki/Hyperoperation ( ইদ্রিস সংজ্ঞা সরাসরি অনুবাদ।)

— Orjan Johansen

Answer 11

হাস্কেল, 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

Comments

টাইপটি sumহ'ল ghc 8.0.2 এর সাথে 1814 অক্ষর হয়ে (Num a, Foldable t) => t a -> a

— ওঠে

Answer 12

সিলোন, 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::empty22 টি অক্ষর দীর্ঘ, এবং প্রতিটি 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 এ প্রবেশ করে 38383546786070481 দেয় Of অবশ্যই এটি আমার কম্পিউটারের স্মৃতিতে (8 8 10 ⁹ বাইট) মাপসই করবে তার চেয়ে অনেক বড় ।

অবশ্যই, সংকলকটি স্মার্ট হতে পারে এবং নামটির অনুরোধ না করা পর্যন্ত পুরো টাইপটির নাম স্মৃতিতে রাখার চেষ্টা না করে।

এখানে প্রকারটি প্রিন্ট করার চেষ্টা করা সম্পূর্ণ প্রোগ্রাম:

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

Answer 13

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 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]]]]]]]]]]]]]]]]]]]]]]]]