एक लंबे प्रकार के हस्ताक्षर करें

Question

चुनौती

सबसे लंबे प्रकार के हस्ताक्षर के साथ, अधिकतम 100 बाइट्स पर एक अभिव्यक्ति प्राप्त करें।

नियम

• किसी भी वैधानिक रूप से टाइप की गई भाषा जिसमें अनुमान है, की अनुमति है
• प्रकार गैर-अस्पष्ट होना चाहिए, लेकिन अन्यथा बिना परिभाषित उदाहरणों के प्रकार शामिल हो सकते हैं। उदाहरण के लिए Num [a]और Eq [a]एक निर्धारित उदाहरण के बिना भी अनुमति है
• STDIN / STDOUT के साथ एक कार्यक्रम को संकलित करने के लिए आवश्यक न्यूनतम के अलावा कोई आयात नहीं
• अनंत प्रकार की अनुमति नहीं है
• यदि एक उत्तर में एक से अधिक अभिव्यक्ति हैं, तो केवल एक ही स्कोर में योगदान दे सकता है। उदाहरण के लिए, हालांकि रचना का प्रकार हस्ताक्षर (.) :: (b -> c) -> (a -> b) -> a -> c20 का स्कोर है, 25 प्रतियों के साथ उत्तर (.)\nमें 20 का स्कोर होगा, न कि 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 वें n.बड़ा होने जा रहा है। 2^18बनाम 3 * (2^16)जब तक मैंने मूल घातांक की गणना करने में गलती नहीं की: 2^(4^9)बनाम3^((4^8)*3)

— ड्रेको

नहीं, @PeterTaylor सही है: 2 ^ (4 ^ 9) = 16 ^ (4 ^ 8) <27 ^ (4 ^ 8) = 3 ^ (4 ^ 8) 3)।

— एंडर्स कासोर्ग

(,)(या (,,)) कुछ बाइट्स को बचाने और अधिक nएस का उपयोग करके स्कोर में सुधार करने के लिए इस्तेमाल किया जा सकता है ।

— ।

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

हम्म। चूँकि लैम्ब्डा की अनुमति है, इसलिए संभवतः इसे एक उच्च स्कोर मिलेगा

— ASCII-only

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

व्याख्या

#प्रकार परिवार निकट से संबंधित है एकरमैन-पीटर समारोह , आमतौर पर लिखित $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

— अर्जन जोहान्सन

@ UprjanJohansen, 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 262 ²⁶²¹⁴⁴ + 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]]]

और इतने पर, लंबाई लगभग प्रत्येक के लिए दोगुनी हो (:) । दी गई अभिव्यक्ति 2 · 4 ⁶ · 3 ⁴ = 663552 प्रतियों के साथ o.o.oकाम करती है ।(:).(:).(:).….(:)(:)

हास्केल FlexibleContextsऔर NoMonomorphismRestriction, (200 · 4 ³³¹⁷⁷⁶ + 75 · 331776 + 16) / 9 3 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]]]

और इतने पर, प्रत्येक के लिए लंबाई लगभग चौगुनी के साथ (/).(:)। दी गई अभिव्यक्ति 4 ⁶ · 3 ⁴ = 331776 प्रतियों के साथ -o.o.oकाम करती है ।-(/).(:).(/).(:).….(/).(:)(/).(:)

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 प्रविष्टि जैसा दिखता है। संभवतः परिमाण में सबसे बड़ा परिवर्तन मैंने कभी PPCG प्रविष्टि में परिष्कृत होते हुए देखा है।

— स्पार्स

@ आप अभी तक नथिन को नहीं देख

— बिल्ली

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

मुझे याद है कि C ++ के कुछ बहुत पुराने (पूर्व-मानक?) संस्करण थे जो कीवर्ड के classबजाय उपयोग करते थे typename। मुझे आश्चर्य है कि अगर वहाँ एक कंपाइलर कहीं है जो अभी भी पिछड़े संगतता के लिए उस phrasing का समर्थन करता है?

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

जाओ बिना 1.0 reflect, 98

1.x प्रकार को सांख्यिकीय रूप से परिभाषित किया गया है। यहाँ मेरा पहला प्रयास है:

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

खेल के मैदान पर :

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

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

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

1.9 प्रकार के उपनामों का उपयोग करके गो, 2389

type(I=interface{f();g()};S=struct{p,q,r,s,t,u,v,w,x,y,z I});map[S]map[S]map[S]map[S]map[S]map[S]S{}

खेल के मैदान पर :

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

    type(I=interface{f();g()};S=struct{p,q,r,s,t,u,v,w,x,y,z I});x:=map[S]map[S]map[S]map[S]map[S]map[S]S{}

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

परिणाम:

2389 map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }

1 का उपयोग कर जाओ reflect, 65532

नहीं है पैकेज में एक सीमाreflect प्रकार के नाम की लंबाई पर:len(name) <= 1<<16-1

मैं इस ब्लॉक के साथ अब तक 65532 बाइट्स के एक प्रकार तक पहुंचने में सक्षम हूं:

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

खेल के मैदान पर पूर्ण कोड :

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आयात को गिनना होगा

— ASCII- केवल

3403?

— एएससीआईआई-केवल

3685

— एएससीआईआई-केवल

65535

— एएससीआईआई-केवल

Answer 10

इदरीस,> हाइपर (हाइपर (हाइपर (हाइपर 9999999, 99, 99), 99,99), 99,99), 99,99)

f:Nat->Type
f Z=()
f(S n)=hyper n n n~=~f n
the$f$hyper(hyper(hyper(hyper 999999999 9 9) 9 9)9 9)9 9

स्पष्टीकरण:

हम एक फ़ंक्शन f को परिभाषित कर रहे हैं, एक प्रकार f (0) की गणना करना केवल इकाई प्रकार है, जबकि f (S (n)) फ़ंक्शन तर्क पर लागू समानता प्रकार की गणना "हाइपरेटेड" अपने आप करता है और n पर लागू होता है। । अंतिम पंक्ति मूल रूप से एक फ़ंक्शन है जो एक प्रकार के मूल्य की उम्मीद करता है जैसे (27 = (4 = (2 = (1 = ())))) (n = 4 के लिए)।

सरल उदाहरण

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

Comments

मैं वास्तव में इदरीस को नहीं जानता, लेकिन मुझे लगता है कि यह एक तकनीकी पर विफल हो सकता है: आप किसी अभिव्यक्ति के प्रकार के हस्ताक्षर की लंबाई को अधिकतम करने वाले हैं, न कि इसके मूल्य की लंबाई को। क्या आपकी अंतिम अभिव्यक्ति का प्रकार केवल हस्ताक्षर नहीं है :Type?

— अर्जन जोहान्सन

एक असम्बद्ध संख्या से आपका क्या तात्पर्य है ? मैं परिचित नहीं हूँ hyper; क्या आप समझाएँगे?

— dfeuer

@ FixedrjanJohansen ओह हाँ, बस तय है कि और कुछ और परिवर्तन लागू

— मेगा मैन

(०) स्पष्टीकरण थोड़ा पिछड़ता हुआ प्रतीत होता है। (1) यह अभी केवल 98 बाइट्स है। (२) चूँकि पहला तर्क hyperबाकी की तुलना में बहुत अधिक बढ़ जाता है, मुझे लगता है कि आप चाहते हैं कि सभी / अधिकांश लोग 99एस हो जाएं 9। (३) इदरीस के $काम को हास्केल की तरह मान लेना , बाद में कोष्ठक का बाहरी सेट f$बेमानी है। (४) क्या आप संक्षिप्त hyperया स्वयं एक प्रकार के हस्ताक्षर की आवश्यकता होगी?

— अर्जन जोहान्सन

@dfeuer en.wikipedia.org/wiki/Hyperoperation ( इदरिस की परिभाषा इसका सीधा अनुवाद है।)

— अर्जन जोहान्सन

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

GHC 8.0.2 के साथ 1814 वर्ण हो जाता है, के प्रकार के रूप में sumतो है(Num a, Foldable t) => t a -> a

— मैथ्यु CAROFF

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

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