हाल ही में मुझे एक हास्केल कार्यक्रम लिखने का आनंद मिला जो यह पता लगा सकता था कि क्या NegativeLiteralsविस्तार में लगे हुए हैं। मैं निम्नलिखित के साथ आया:

data B=B{u::Integer}
instance Num B where{fromInteger=B;negate _=B 1}
main=print$1==u(-1)

यह Trueसामान्य रूप से और Falseअन्यथा मुद्रित होगा ।

अब मुझे ऐसा करने में बहुत मज़ा आ रहा था, मैं आप सभी को चुनौती दे रहा हूँ। आप किस अन्य हास्केल भाषा एक्सटेंशन को क्रैक कर सकते हैं?

नियम

किसी विशेष भाषा एक्सटेंशन को क्रैक करने के लिए आपको एक हास्केल प्रोग्राम लिखना होगा जो भाषा एक्सटेंशन के साथ और उसके बिना दोनों को संकलित करता है (चेतावनियां ठीक हैं) और भाषा एक्सटेंशन के साथ चलने पर दो अलग - अलग गैर-त्रुटि मानों को आउटपुट करता है और यह बंद हो गया ( Noउपसर्ग जोड़कर) भाषा का विस्तार)। इस तरह ऊपर दिए गए कोड को छोटा किया जा सकता है:

data B=B{u::Integer}
instance Num B where{fromInteger=B;negate _=B 1}
main=print$u(-1)

जो प्रिंट करता है 1और -1।

किसी एक्सटेंशन को क्रैक करने के लिए आपके द्वारा उपयोग की जाने वाली कोई भी विधि उस एक्सटेंशन के लिए विशिष्ट होनी चाहिए। मनमाने ढंग से पता लगाने के तरीके हो सकते हैं कि संकलक झंडे या LanguageExtensions सक्षम हैं, यदि ऐसा है तो ऐसे तरीकों की अनुमति नहीं है। आप अतिरिक्त भाषा एक्सटेंशन सक्षम कर सकते हैं या -Oअपने बाइट काउंट के लिए बिना किसी लागत के कंपाइलर ऑप्टिमाइज़ेशन को बदल सकते हैं।

भाषा एक्सटेंशन

आपको लगता है कि एक नहीं है किसी भी भाषा विस्तार दरार नहीं कर सकते Noसमकक्ष (जैसे Haskell98, Haskell2010, Unsafe, Trustworthy, Safe) क्योंकि इन शब्दों के ऊपर उल्लिखित के अंतर्गत नहीं आता। हर दूसरे भाषा का विस्तार निष्पक्ष खेल है।

स्कोरिंग

आपको हर भाषा एक्सटेंशन के लिए एक बिंदु से सम्मानित किया जाएगा, जिसे आप क्रैक करने वाले पहले व्यक्ति हैं और हर भाषा एक्सटेंशन के लिए एक अतिरिक्त बिंदु जिसके लिए आपके पास सबसे छोटा (बाइट्स में मापा गया) दरार है। दूसरे बिंदुओं के लिए संबंध पहले के सबमिशन के पक्ष में टूट जाएंगे। उच्च अंक बेहतर है

आप पहले प्रस्तुत करने के लिए एक बिंदु स्कोर नहीं कर पाएंगे NegativeLiteralsया QuasiQuotesक्योंकि मैंने पहले ही उन्हें क्रैक कर दिया है और उन्हें पोस्ट के शरीर में शामिल किया है। हालाँकि आप इनमें से प्रत्येक की सबसे छोटी दरार के लिए एक बिंदु बना पाएंगे। यहाँ मेरी दरार हैQuasiQuotes

import Text.Heredoc
main=print[here|here<-""] -- |]

इसे ऑनलाइन आज़माएं!

— गेहूं का जादूगर
स्रोत

3

मुझे लगता है कि यह सभी वैध विकल्पों की एक सूची है

— H.PWiz

1

ध्यान दें कि मेरी उपरोक्त टिप्पणी में NondecreasingIndentationस्पष्ट कारण शामिल नहीं हैं

— H.PWiz

4

मुझे लगता है कि यह शीर्षक भ्रामक है, क्योंकि एकमात्र भाषा जिसका आप उपयोग कर सकते हैं, हास्केल है। कैसे के बारे में Wait, what language extension is this?या कुछ पूरी तरह से अलग है।

— एमडी XF

1

मैं काफी उत्सुक हूं कि क्या यह संभव है कि RelaxedPolyRecएक कंपाइलर प्राचीन के लिए वास्तव में इसे बंद करने का समर्थन करता है। (विकल्प के आसपास लटका दिया गया, प्रलेखन के साथ, कुछ वर्षों के बाद कुछ भी करना बंद कर दिया।)

— dfeuer

1

@dfeuer इस टिकट को देखकर ऐसा लगता है जैसे GHC 6.12.1 ने इसे बंद करने का समर्थन किया है।

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

24

मैजिकहाश, 30 बाइट्स

x=1
y#a=2
x#a=1
main=print$x#x

-XMagicHash आउटपुट 1, -XNoMagicHash आउटपुट 2

MagicHash एक में समाप्त करने के लिए चर नामों की अनुमति देता है #। इसलिए विस्तार के साथ, यह दो कार्यों को परिभाषित करता है y#और x#जो प्रत्येक एक मान लेते हैं और एक स्थिर लौटाते हैं 2, या 1। x#x1 लौटेगा (क्योंकि यह x#लागू होता है 1)

विस्तार के बिना, यह एक फ़ंक्शन को परिभाषित करता है #जो दो तर्क और रिटर्न लेता है 2। x#a=1एक पैटर्न है कि तक पहुँच जाता है कभी नहीं है। फिर x#xहै 1#1, जो 2 देता है।

— H.PWiz
स्रोत

2

मैं अब डांस मैजिक डांस की धुन पर एक्स मैजिक हैश गा रहा हूं । मुझे आशा है कि आपको गर्व होगा!

— TRIG

मैं हैरान हूं कि MagicHashगैर-ट्रेलिंग हैश की अनुमति नहीं है। अजीब!

— डेफ्यूअर

18

सीपीपी, 33 20 बाइट्स

main=print$0-- \
 +1

के 0साथ -XCPPऔर 1साथ प्रिंट -XNoCPP।

नई लाइन को हटाने से पहले -XCPPएक स्लैश के साथ , \इस प्रकार कोड बन जाता है main=print$0-- +1और केवल 0प्रिंट हो जाता है क्योंकि +1अब वह टिप्पणी का हिस्सा है।

ध्वज के बिना टिप्पणी को नजरअंदाज किया जाता है और दूसरी पंक्ति को पिछली पंक्ति के एक भाग के रूप में पार्स किया जाता है क्योंकि यह इंडेंटेड है।

पिछले दृष्टिकोण के साथ `#define`

x=1{-
#define x 0
-}
main=print x

इसके अलावा प्रिंट 0के साथ -XCPPऔर 1साथ -XNoCPP।

— Laikoni
स्रोत

2

हे भगवान, अब तक मैंने सोचा था कि जीएचसी सीपीपी को पारित करने से पहले हास्केल की टिप्पणियों को हटा देगा।

— घन

@ क्यूबिक क्या यह प्री -प्रोसेसर नहीं है ?

— बरगी

1

@Bergi ज़रूर, लेकिन प्री -प्रोसेसर का मतलब यह नहीं है कि "पहली चीज है जो चलती है", खासकर जब से जीएचसी को प्राग्मा खोजने के लिए पहले फाइल पर एक पास बनाना पड़ता है। मुझे लगता है कि टिप्पणियों को डॉक टिप्पणियों में रखा गया है और सीपीपी के बाद जैसा काम किया गया है।

— घन

14

NumDecimals, 14 बाइट्स

main=print 1e1

-XNumDecimals प्रिंट 10। -XNoNumDecimals प्रिंट 10.0।

— H.PWiz
स्रोत

14

बाइनरीलिटरल, 57 बाइट्स

b1=1
instance Show(a->b)where;show _=""
main=print$(+)0b1

-XBinaryLiterals एक नई रूपरेखा प्रिंट करता है। -XNoBinaryLiterals प्रिंट करता है a 1।

मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका है। यदि आपको एक मिल जाए, तो कृपया इसे पोस्ट करें।

— H.PWiz
स्रोत

क्या आप केवल bएक फ़ंक्शन के रूप में परिभाषित नहीं कर सकते हैं (इसलिए कोई बाइनरी नहीं बनता है b(0, 1), लेकिन बाइनरी बन जाता है 0b1)?

— NoOneIsHere

12

मोनोमोर्फिस्मरट्रिशन + 7 अन्य, 107 बाइट्स

यह TH का उपयोग करता है जिसके लिए -XTemplateHaskellहर समय ध्वज की आवश्यकता होती है ।

फ़ाइल T.hs, 81 + 4 बाइट्स

module T where
import Language.Haskell.TH
p=(+)
t=reify(mkName"p")>>=stringE.show

मुख्य, 22 बाइट्स

import T
main=print $t

ध्वज के साथ संकलन MonomorphismRestriction के प्रकार के बलों pके लिए Integer -> Integer -> Integerऔर इस तरह निम्नलिखित उत्पादन का उत्पादन:

"VarI T.p (AppT (AppT ArrowT (ConT GHC.Integer.Type.Integer)) (AppT (AppT ArrowT (ConT GHC.Integer.Type.Integer)) (ConT GHC.Integer.Type.Integer))) Nothing"

ध्वज के साथ संकलित करना NoMonomorphismRestrictionp सबसे सामान्य, यानी के प्रकार को छोड़ देता है । Num a => a->a->a- जैसे कुछ उत्पादन करना ( VarTनाम छोटा करना a):

"VarI T.p (ForallT [KindedTV a StarT] [AppT (ConT GHC.Num.Num) (VarT a)] (AppT (AppT ArrowT (VarT a)) (AppT (AppT ArrowT (VarT a)) (VarT a)))) Nothing"

उन्हें ऑनलाइन कोशिश करो!

वैकल्पिक

चूंकि उपरोक्त कोड बस के प्रकार को प्रिंट करता है p, इसलिए यह उन सभी झंडों के साथ किया जा सकता है जो किसी तरह से प्रभावित करते हैं कि हास्केल कैसे टाइप करता है। मैं केवल ध्वज को निर्दिष्ट करूंगा कि फ़ंक्शन को क्या बदलना है pऔर यदि अतिरिक्त झंडे की आवश्यकता है (इसके अलावा -XTemplateHaskell):

ओवरलोडेडलिस्ट्स, 106 बाइट्स

इसके अतिरिक्त जरूरतें -XNoMonomorphismRestriction:

p=[]

या तो p :: [a]या p :: IsList l => l, उन्हें ऑनलाइन आज़माएं!

ओवरलोडेड स्प्रिंग्स, 106 बाइट्स

इसके अतिरिक्त जरूरतें -XNoMonomorphismRestriction:

p=""

या तो p :: Stringया p :: IsString s => s, उन्हें ऑनलाइन आज़माएं!

PolyKinds, 112 बाइट्स

यह @CsongorKiss को पूरी तरह वजह से है:

data P a=P

या तो P :: P aया P :: forall k (a :: k). P a, उन्हें ऑनलाइन आज़माएं!

MonadComprehensions, 114 बाइट्स

p x=[i|i<-x]

या तो p :: [a] -> [a]या p :: Monad m => m a -> m a, उन्हें ऑनलाइन आज़माएं!

NamedWildCards, 114 बाइट्स

यह @ लिकोनी द्वारा पाया गया था, इसके अतिरिक्त इसकी आवश्यकता है -XPartialTypeSignatures:

p=id::_a->_a

उनके पास दोनों प्रकार के p :: a -> aजतन हैं ( ) लेकिन GHC चरों के लिए अलग-अलग नाम उत्पन्न करता है, उन्हें ऑनलाइन आज़माएं!

एप्लीकेडो, 120 बाइट्स

p x=do i<-x;pure i

या तो p :: Monad m => m a -> m aया p :: Functor f => f a -> f a, उन्हें ऑनलाइन आज़माएं!

ओवरलोडलेबल, 120 बाइट्स

इसके लिए अतिरिक्त ध्वज की आवश्यकता है -XFlexibleContexts:

p x=(#id)x
(#)=seq

या तो के रूप में p :: a -> b -> bया p :: IsLabel "id" (a->b) => a -> b, उन्हें ऑनलाइन प्रयास करें!

— ბიმო
स्रोत

क्या अन्य झंडे के लिए एक समान काम करता है?

— एच.पी.विज

हाँ, आप इसे सुनिश्चित करने के लिए OverloadedStringsया OverloadedListsशायद दूसरों के साथ भी कर सकते हैं ..

— '

2

यह भी साथ काम करता है PolyKinds: इसे ऑनलाइन आज़माएं!

— सोंगोर चुंबन

1

इसके साथ काम करने के लिए भी लगता है NamedWildCards: इसे ऑनलाइन आज़माएं! (आवश्यकता है -XPartialTypeSignatures)

— लैकोनी

10

सीपीपी, २ 25 २५

main=print({-/*-}1{-*/-})

इसे ऑनलाइन आज़माएं!

के ()लिए -XCPPऔर के 1लिए प्रिंट-XNoCPP

पुराना वर्जन:

main=print[1{-/*-},2{-*/-}]

इसे ऑनलाइन आज़माएं!

प्रिंट के [1]साथ -XCPPऔर [1,2]अन्यथा।

क्रेडिट: यह लाइकोनी के उत्तर से प्रेरित है, लेकिन इसके बजाय #defineयह केवल सी टिप्पणियों का उपयोग करता है।

— celtschk
स्रोत

9

स्कोपेडाइपवियर्स, 162 113 बाइट्स

instance Show[()]where show _=""
p::forall a.(Show a,Show[a])=>a->IO()
p a=(print::Show a=>[a]->IO())[a]
main=p()

-XScopedTypeVariables प्रिंट्स ""(खाली), -XNoScopedTypeVariables प्रिंट्स "[()]"।

संपादित करें: अद्यतन समाधान टिप्पणियों में उपयोगी सुझावों के लिए धन्यवाद

— सोंगोर चुंबन
स्रोत

1

ओह समझा। आम तौर पर शरीर में अपने कोड को शामिल करने के लिए अच्छे होते हैं, लेकिन ungolfed संस्करण भी अच्छे होते हैं। मैं भी देख रहा हूँ कि "T"बस के साथ प्रतिस्थापित किया जा सकता है ""।

— गेहूं जादूगर

2

एक और बात आप कर सकते हैं अपने डेटाप्रकार की जगह है Tके साथ ()। इसे परिभाषित करने से बचने के लिए। इसे ऑनलाइन आज़माएं!

— गेहूं जादूगर

1

अच्छी पकड़, मुझे बस एहसास हुआ कि असंगत प्रागम को एक ध्वज के रूप में शामिल किया जा सकता है: इसे ऑनलाइन आज़माएं!

— सोंगोर चुंबन

2

इसके अतिरिक्त प्रिंट केshow लिए बदला जा सकता है

— H.PWiz

के लिए यूनिकोड सिंटैक्स forallआपको कुछ बाइट्स बचाएगा। मैं किसी भी समाधान पर संदेह करता हूं जिसे अतिरिक्त उदाहरणों की आवश्यकता है, हालांकि जीत की बहुत उम्मीद है।

— 10

9

मोनोक्लोनलबाइंड, जीएडीटी या टाइपफैमिली, 36 32 बाइट्स

संपादित करें:

-4 बाइट्स: इस के एक संस्करण को स्टैसॉइड द्वारा महान पॉलीग्लॉट श्रृंखला में शामिल किया गया था , जिन्होंने मुझे सभी घोषणाओं को शीर्ष स्तर पर डालकर आश्चर्यचकित कर दिया था। जाहिरा तौर पर इस प्रतिबंध को ट्रिगर करने के लिए वास्तविक स्थानीय बाइंडिंग की आवश्यकता नहीं होती है ।

a=0
f b=b^a
main=print(f pi,f 0)

साथ कोई एक्सटेंशन , इस कार्यक्रम प्रिंट (1.0,1)।
किसी भी झंडे के साथ -XMonoLocalBinds , -XGADTs , या -XTypeFamilies , यह प्रिंट करता है (1.0,1.0)।
MonoLocalBindsएक्सटेंशन कुछ unintuitive प्रकार निष्कर्ष GADTs और प्रकार परिवारों से शुरू हो रहा रोकने के लिए मौजूद है। इस प्रकार, यह एक्सटेंशन दो अन्य लोगों द्वारा स्वचालित रूप से चालू हो जाता है।
यह है इसे बंद करने के लिए फिर से स्पष्ट रूप से संभव -XNoMonoLocalBindsहै, इस चाल तुम नहीं हो जाती है।
अपने अधिक प्रसिद्ध चचेरे भाई की तरह मोनोमोर्फिज्म प्रतिबंध, MonoLocalBindsकुछ मूल्यों ( ~~जैसे स्थानीय बाइंडिंग में letया where, इस प्रकार~~ जाहिरा तौर पर यह ~~नाम~~ शीर्ष स्तर पर भी हो सकता है) को बहुरूपी होने से रोककर काम करता है । सैनर प्रकार के अनुमान के लिए बनाए जाने के बावजूद, जब यह ट्रिगर होता है तो नियम एमआर की तुलना में अधिक बालों वाले होते हैं।
किसी भी विस्तार के बिना, उपरोक्त कार्यक्रम infers प्रकार f :: Num a => a -> aकी अनुमति f piएक डिफ़ॉल्ट Doubleऔर f 0एक करने के लिए Integer।
एक्सटेंशन के साथ, प्रकार का अनुमान हो जाता है f :: Double -> Double, और साथ ही f 0वापस लौटना पड़ता है Double।
a=0तकनीकी नियमों को ट्रिगर करने के लिए अलग चर की आवश्यकता होती है: aमोनोमोर्फिज्म प्रतिबंध द्वारा मारा जाता है, और aका एक मुक्त चर है f, जिसका अर्थ है कि fबाध्यकारी समूह पूरी तरह से सामान्यीकृत नहीं है , जिसका अर्थ fहै कि बंद नहीं है और इस प्रकार बहुरूपी नहीं बनता है।

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

9

ओवरलोडेड स्प्रिंग्स, 65 48 32 बाइट्स

RebindableSyntax का लाभ उठाते हुए, किसी भी स्ट्रिंग शाब्दिक को चालू करने के लिए अपने स्वयं के संस्करण का उपयोग करें "y"।

main=print""
fromString _=['y']

के साथ संकलित किया जाना चाहिए -XRebindableSyntax -XImplicitPrelude।

-XOverloadedStringsप्रिंट के बिना ""; प्रिंट के साथ "y"।

इसके अलावा, यह केवल अब मुझे मारा कि एक ही तकनीक के साथ काम करता है (जैसे) अतिभारित

ओवरलोडेडलिस्ट्स, 27 बाइट्स

main=print[0]
fromListN=(:)

के साथ संकलित किया जाना चाहिए -XRebindableSyntax -XImplicitPrelude।

-XOverloadedListsप्रिंट के बिना [0]; प्रिंट के साथ [1,0]।

— felixphew
स्रोत

1

आप अंतिम पंक्ति को छोटा कर सकते हैं fromString a=['y']।

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

इसमें जगह print "n"भी छोड़ी जा सकती है।

— लैकोनी

@ ØrrrJohansen धन्यवाद! मैं इसके साथ असफल रहा था ="y", लेकिन =['y']ठीक काम करता है!

— felixphew

1

आप दूसरे को हटा सकते हैं nसेprint"n"

— गेहूं जादूगर

1

आप आयात लाइन से बचने के -XImplicitPreludeबाद भी उपयोग कर सकते हैं RebindableSyntax।

— dfeuer

8

बैंगटैटन, 32 बाइट्स

(!)=seq
main|let f!_=0=print$9!1

-XBangPatterns प्रिंट करता है 1जबकि -XNoBangPatterns प्रिंट करेगा 0।

यह उपयोग करता है कि ध्वज BangPatterns WHNF को !मूल्यांकन करने के लिए बल के साथ पैटर्न को एनोटेट करने की अनुमति देता है , उस स्थिति 9!1में शीर्ष-स्तरीय परिभाषा का उपयोग करेगा (!)=seq। यदि ध्वज सक्षम नहीं f!_है, तो नया ऑपरेटर परिभाषित करता है (!)और शीर्ष-स्तरीय परिभाषा को छायांकित करता है।

— ბიმო
स्रोत

7

एप्लीकेडो, 104 बाइट्स

import Control.Applicative
z=ZipList
instance Monad ZipList where _>>=_=z[]
main=print$do a<-z[1];pure a

इसे ऑनलाइन आज़माएं!

इसके साथ ApplicativeDo, यह प्रिंट करता है

ZipList {getZipList = [1]}

इसके बिना, यह प्रिंट करता है

ZipList {getZipList = []}

ZipListबेस लाइब्रेरी में कुछ प्रकारों में से एक है, जिसके लिए एक उदाहरण है, Applicativeलेकिन इसके लिए नहीं Monad। कहीं न कहीं कम विकल्प हो सकते हैं।

— Zgarb
स्रोत

7

सख्त, 87 84 82 बाइट्स

^{-5 बाइट्स के लिए धन्यवाद dfeuer !}

BlockArgumentsआसपास के परिंदों को बचाने के साथ कम हो सकता है \_->print 1:

import Control.Exception
0!_=0
main=catch @ErrorCall(print$0!error"")(\_->print 1)

के साथ इस रनिंग -XStrict एक प्रिंट 1जबकि साथ इसे चलाने -XNoStrict एक प्रिंट होगा 0। यह उपयोग करता है कि डिफ़ॉल्ट रूप से हास्केल आलसी है और इसका मूल्यांकन करने की आवश्यकता नहीं है error""क्योंकि यह पहले से ही जानता है कि इसका परिणाम 0तब होगा जब यह पहले तर्क पर मेल खाता है (!), इस व्यवहार को उस ध्वज के साथ बदला जा सकता है - दोनों तर्कों का मूल्यांकन करने के लिए रनटाइम के लिए मजबूर करना।

यदि किसी एक मामले में कुछ भी नहीं छापने की अनुमति दी जाती है तो हम इसे 75 बाइट्स तक ले जा सकते हैं, जिसमें से मुख्य बाइट्स को बदल दिया जाएगा ( डिफ्यूज़ द्वारा कुछ बाइट्स बंद ):

main=catch @ErrorCall(print$0!error"")mempty

स्ट्रिक्टडाटा, 106 99 93 बाइट्स

^{-15 बाइट्स dfeuer के लिए धन्यवाद !}

यह मूल रूप से एक ही करता है लेकिन इसके बजाय डेटा फ़ील्ड के साथ काम करता है:

import Control.Exception
data D=D()
main=catch @ErrorCall(p$seq(D$error"")0)(\_->p 1);p=print

प्रिंटों 1के साथ -XStrictData झंडा और 0साथ -XNoStrictData ।

यदि एक मामले में कुछ भी नहीं छापने की अनुमति दी जाती है तो हम इसे 86 बाइट्स तक ले जा सकते हैं, जो कि मुख्य बाइट्स को बदल देगा (19 बाइट्स को डयूटीअर द्वारा बंद ):

main=catch @ErrorCall(print$seq(D$error"")0)mempty

नोट: सभी समाधानों के लिए TypeApplicationsसेट की आवश्यकता होती है।

— ბიმო
स्रोत

आप इसे बहुत आसानी से 98 बाइट्स तक काट सकते हैं, जो मेरे (बहुत अलग) समाधान से बिल्कुल मेल खाता है। TIO ।

— 9

वास्तव में, आप और भी बेहतर कर सकते हैं: अपवाद हैंडलर में मुद्रण के बजाय, बस उपयोग करें pure()।

— 9

1

@ फ़ेडरर: अच्छा, D{}चाल बहुत अच्छी है! :) के PartialTypeSignaturesबजाय का उपयोग करके एक दूसरे को बंद कर दियाScopedTypeVariables

— at

1

@ फ़ेडरर: मैंने एक नज़र देखा और कुछ चीजों की कोशिश की, लेकिन मैंने कभी भी जेनरिक का इस्तेमाल नहीं किया, इसलिए मैं शायद सही व्यक्ति नहीं हूं।

— ბიმო

1

आप रक्तस्रावी बढ़त जीएचसी के साथ और भी बेहतर कर सकते हैं -XBlockArguments:main=catch @ErrorCall(p$seq(D$error"")1)\_->p 3

— फ़ौजी

6

एप्लीकेडो, 146 बाइट्स

newtype C a=C{u::Int}
instance Functor C where fmap _ _=C 1
instance Applicative C
instance Monad C where _>>=_=C 0
main=print$u$do{_<-C 0;pure 1}

जब आवेदन को सक्षम किया जाता है तो प्रिंट 1, अन्यथा 0

इसे ऑनलाइन आज़माएं!

— oisdk
स्रोत

1

धन्यवाद! आह, मुझे लगता है कि मैं जीएचसी के पुराने संस्करण पर हूं ("कोई आवेदक नहीं" मेरे सिस्टम पर एक चेतावनी थी)

— oisdk

3

का उपयोग करते हुए -XDeriveAnyClass आप प्राप्त कर सकते हैं Applicativeऔर Showरिकॉर्ड सिंटेक्स के उपयोग को बचाने के लिए, देखना यह ।

— ।

6

बाइनरीलिटरल, 31 24 बाइट्स

संपादित करें:

-7 बाइट्स: H.PWiz ने एकल b12चर का उपयोग करके इसे आगे समायोजित करने का सुझाव दिया ।

फ़ंक्शन उदाहरण से बचने के लिए H.PWiz की विधि के लिए एक समायोजन ।

b12=1
main=print$(+)0b12

-XNoBinaryLiterals के साथ , 0b12lexes के रूप में 0 b12, मुद्रण 0 + 1 = 1।
-XBinaryLiterals के साथ , 0b12lexes के रूप में 0b1 2, मुद्रण 1 + 2 = 3।

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

6

ExtendedDefaultRules, 54 53 बाइट्स

instance Num()
main=print(toEnum 0::Num a=>Enum a=>a)

के ()साथ -XExtendedDefaultRulesऔर 0साथ प्रिंट -XNoExtendedDefaultRules।

यह ध्वज GHCi में डिफ़ॉल्ट रूप से सक्षम है, लेकिन GHC में नहीं है, जिसने हाल ही में मेरे लिए कुछ भ्रम पैदा किया है , हालांकि BMO जल्दी से मदद करने में सक्षम था।

उपरोक्त कोड GHC उपयोगकर्ता गाइड में एक उदाहरण का एक गोल्फ संस्करण है जहां GHCi में डिफ़ॉल्ट रूप से समझाया गया है।

-1 बाइट धन्यवाद अर्जन जोहान्सन को !

— Laikoni
स्रोत

इस कोड को पॉलीग्लॉट (जहां कोष्ठक कुछ परेशानी देते हैं) में उधार को देखते हुए , मुझे याद आया कि जीएचसी एक बाइट कम सिंटैक्स का समर्थन करता है toEnum 0::Num a=>Enum a=>a।

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

आप के साथ 48 बाइट्स के लिए नीचे प्राप्त कर सकते हैं PartialTypeSignatures: main=print(toEnum 0::_=>Num a=>a)। साथ ही, आपका TIO लिंक पुराना हो चुका है।

— डेफ्यूअर

6

रीबिंडेबल सिंथेट , 25 बाइट्स

मैं हाल ही में पोस्ट की गई गाइड को जीएचसी के एक्सटेंशन में पढ़ रहा था जब मैंने एक आसान पर ध्यान दिया जिसे मैंने अभी तक यहां याद नहीं किया।

main|negate<-id=print$ -1

-XNoRebindableSyntax के साथ , प्रिंट करता है -1।
साथ -XebindableSyntax , प्रिंट 1।

इसके अलावा -XImplicitPrelude, या वैकल्पिक import Preludeरूप से कोड में ही आवश्यक है।

-XRebindableSyntax इसे फिर से परिभाषित करने के लिए हस्केल के कुछ सिंथेटिक चीनी के व्यवहार को बदल देता है।
-1के लिए सिंथेटिक चीनी है negate 1।
आम तौर पर यह negateहै Prelude.negate, लेकिन विस्तार के साथ यह "जो भी negateउपयोग के बिंदु पर गुंजाइश है", जिसे इस रूप में परिभाषित किया गया है id।
चूँकि विस्तार का उपयोग Preludeमॉड्यूल के प्रतिस्थापन करने के लिए किया जाता है , यह स्वचालित रूप से उस के सामान्य निहित आयात को निष्क्रिय कर देता है, लेकिन अन्य Preludeकार्यों (जैसे print) की यहां आवश्यकता है, इसलिए इसे फिर से सक्षम किया गया है -XImplicitPrelude।

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

6

सख्त, 52 बाइट्स

import GHC.IO
f _=print()
main=f$unsafePerformIO$f()

-XStrict

-XNoStrict

के साथ -XStrict, ()एक अतिरिक्त समय प्रिंट करता है।

दो बाइट्स के लिए @Sriotchilism O'Zaic का धन्यवाद।

— dfeuer
स्रोत

6

स्ट्रिक्टडाटा, 58 बाइट्स

import GHC.Exts
data D=D Int
main=print$unsafeCoerce#D 3+0

(लिंक थोड़ा पुराना है; ठीक हो जाएगा।)

-XNoStrictData

-XStrictData

आवश्यकता है MagicHash(हमें आयात GHC.Extsकरने के बजाय Unsafe.Coerce) और -O(बिल्कुल आवश्यक, छोटे सख्त क्षेत्रों को अनपैक करने के लिए)।

के साथ -XStrictData, प्रिंट 3. अन्यथा, पूर्व-आवंटित प्रति (शायद टैग किए गए) सूचक के पूर्णांक मान को प्रिंट करता है 3::Integer, जो संभवतः 3 नहीं हो सकता है।

व्याख्या

टाइप डिफॉल्ट के आधार पर थोड़ा विस्तार के साथ समझना थोड़ा आसान होगा। हस्ताक्षर के साथ, हम जोड़ छोड़ सकते हैं।

main=print
  (unsafeCoerce# D (3::Integer)
    :: Integer)

तुल्य,

main=print
  (unsafeCoerce# $
    D (unsafeCoerce# (3::Integer))
    :: Integer)

यह कभी 3 क्यों प्रिंट करता है? यह आश्चर्यजनक लगता है! ठीक है, छोटे Integerमानों को बहुत पसंद किया जाता है जैसे कि Int, (सख्त डेटा के साथ) Dएस की तरह ही प्रतिनिधित्व किया जाता है । हम अंत में टैग की अनदेखी करते हुए बताते हैं कि पूर्णांक छोटा है या बड़ा सकारात्मक / नकारात्मक।

एक्सटेंशन के बिना यह 3 प्रिंट क्यों नहीं कर सकता है? किसी भी मेमोरी लेआउट कारणों को छोड़कर, कम बिट्स (32-बिट के लिए 2 सबसे कम, 64-बिट के लिए 3 निम्नतम) के साथ एक डेटा पॉइंटर तीसरे निर्माता से निर्मित मान का प्रतिनिधित्व करना चाहिए। इस मामले में, एक नकारात्मक पूर्णांक की आवश्यकता होगी ।

— dfeuer
स्रोत

5

UnboxedTuples, 52 बाइट्स

import Language.Haskell.TH
main=runQ[|(##)|]>>=print

की आवश्यकता है -XTemplateHaskell। प्रिंटों ConE GHC.Prim.(##)के साथ -XUnboxedTuples और UnboundVarE ##साथ -XNoUnboxedTuples ।

— Laikoni
स्रोत

आवश्यक विकल्प के लिए स्कोर में एक और +16 नहीं होना चाहिए -XTemplateHaskell?

— celtschk

2

@celtschk मैंने इसे इसलिए नहीं गिना क्योंकि कमांड लाइन के झंडे पर वर्तमान मेटा सर्वसम्मति कहती है कि उनकी गिनती नहीं की जाती है बल्कि इसके बजाय एक नई भाषा बनाई जाती है। हालांकि इसके बारे में सोचने पर मैं देखता हूं कि इस चुनौती के संदर्भ में जो केवल हास्केल के जवाब देने की अनुमति देता है, लेकिन अन्य झंडों के उपयोग से भी यह स्पष्ट नहीं होता है कि क्या करना है। मैं ओपी से इसके बारे में पूछूंगा।

— लैकोनी

मुझे नहीं पता था कि इस पर आम सहमति बदल गई है। सूचक के लिए धन्यवाद। ओपी से पूछना सुनिश्चित करने के लिए एक अच्छा विचार है।

— celtschk

5

ओवरलोडेडलिस्ट्स, 76 बाइट्स

import GHC.Exts
instance IsList[()]where fromList=(():)
main=print([]::[()])

-XOverloadedLists के साथ यह प्रिंट करता है [()]। -XNoOverloadedLists के साथ यह प्रिंट करता है[]

इस अतिरिक्त झंडे की आवश्यकता है: -XFlexibleInstances,-XIncoherentInstances

— H.PWiz
स्रोत

आप अतिव्यापी उदाहरणों के साथ दूर हो सकते हैं।

— डेफ्यूअर

5

HexFloatLiterals , 49 25 बाइट्स

-24 बाइट्स अर्जन जोहान्सन को धन्यवाद।

main|(.)<-seq=print$0x0.0

के 0.0साथ -XHexFloatLiteralsऔर 0साथ प्रिंट -XNoHexFloatLiterals।

कोई TIO लिंक नहीं हैं क्योंकि HexFloatLiterals को ghc 8.4.1 में जोड़ा गया था, लेकिन TIO में ghc 8.2.2 है।

— stasoid
स्रोत

main|(.)<-seq=print$0x0.0आयात छिपाने से बचता है।

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

main|let _._=0=print$0x0.0बहुभुज के लिए हालांकि आसान हो सकता है।

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

5

ScopedTypeVariables, 37 बाइट्स

main=print(1::_=>a):: ∀a.a~Float=>_

यह भी जरूरी है UnicodeSyntax, PartialTypeSignatures, GADTs, और ExplicitForAll।

इसे ऑनलाइन आज़माएं (बिना एक्सटेंशन के)

इसे ऑनलाइन आज़माएं (एक्सटेंशन के साथ)

व्याख्या

आंशिक प्रकार के हस्ताक्षर केवल बाइट्स को बचाने के लिए हैं। हम उन्हें इस तरह भर सकते हैं:

main=print(1::(Num a, Show a)=>a):: ∀a.a~Float=>IO ()

स्कोप्ड प्रकार चर के साथ, के aप्रकार में 1विवश होने aके प्रकार में है main, जो स्वयं होने के लिए विवश है Float। बिना स्केप्ड प्रकार के चर, 1टाइप करने के लिए चूक Integer। चूंकि Floatऔर Integerमान अलग-अलग दिखाए जाते हैं, हम उन्हें अलग कर सकते हैं।

@ JrjanJohansen का शुक्रिया 19 बाइट्स के लिए! उन्होंने महसूस किया कि Showउनके अंकगणित में अंतर की तुलना में विभिन्न संख्यात्मक प्रकार के उदाहरणों के बीच के अंतर का लाभ उठाना बेहतर था । उन्होंने यह भी महसूस किया कि main"वाक्यात्मक रूप से अस्पष्ट" के प्रकार को छोड़ना ठीक था क्योंकि बाधा वास्तव में इसका खंडन करती है। स्थानीय फ़ंक्शन से छुटकारा पाकर मुझे mainपाँच और बाइट्स को बचाने के लिए (RHS में इसे स्थानांतरित करने के लिए) प्रकार के हस्ताक्षर को हटाने के लिए मुक्त कर दिया ।

— dfeuer
स्रोत

45 बाइट्स

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

@ ØrjanJohansen, अच्छा लगा ।

— डिफ्यूअर

@ TherjanJohansen, क्या मुझे संपादन करना चाहिए, या आप खुद जोड़ना चाहेंगे?

— 5

संपादित करें, यह आपका एक क्रमिक विकास था।

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

@ WasrrrJohansen, धन्यवाद, वह सुंदर था।

— डिफ्यूअर

5

DeriveAnyClass, 121 113 बाइट्स

^{काफी कुछ बाइट्स के लिए dfeuer के लिए धन्यवाद !}

import Control.Exception
newtype M=M Int deriving(Show,Num)
main=handle h$print(0::M);h(_::SomeException)=print 1

-XDeriveAnyClass प्रिंट 1जबकि -NNDDiveiveAnyClass प्रिंट M 0।

यह इस तथ्य का शोषण कर रहा है कि DeriveAnyClass डिफ़ॉल्ट रणनीति है जब DeriveAnyClass और GeneralizedNewtypeDeriving दोनों सक्षम हैं, जैसा कि आप चेतावनी से देख सकते हैं। इस ध्वज को खुशी से सभी तरीकों के लिए खाली कार्यान्वयन उत्पन्न होगा लेकिन GeneralizedNewtypeDeriving वास्तव में अंतर्निहित प्रकार के कार्यान्वयन का उपयोग करने के लिए स्मार्ट पर्याप्त है और जब से Intएक Numयह इस मामले में असफल नहीं होंगे।

यदि ध्वज mainद्वारा कुछ भी न छापने की स्थिति में ध्वज को बदल दिया जाए तो निम्नलिखित में से 109 बाइट्स होंगे :

main=print(0::M)`catch`(mempty::SomeException->_)

— ბიმო
स्रोत

में कम से कम runhaskell, यह वास्तव में प्रिंट M 1के साथ -XDeriveAnyClass, आलस्य के कारण ...

— बारी रह गए counterclockwis

@ceasedtoturncounterclockwis: जीएचसीआई में भी, हां, लेकिन जब टीआईओ (और मेरी मशीन) पर संकलन हो रहा है और फिर इसे चलाने का परिणाम है 1:)

— urn

113 बाइट्स

— dfeuer

109 बाइट्स

— dfeuer

1

मैंने इसे 104 में पूरी तरह से अलग कर दिया, इसलिए मैंने अपना जवाब जोड़ दिया।

— डेफ्यूअर

4

PostfixOperators, 63 बाइट्स

import Text.Show.Functions
instance Num(a->b)
main=print(0`id`)

इसे ऑनलाइन आज़माएं (बिना एक्सटेंशन के)

इसे ऑनलाइन आज़माएं (एक्सटेंशन के साथ)

यह एक Hugs / GHC बहुभाषाविद का कट-डाउन संस्करण है जो मैंने लिखा था । स्पष्टीकरण के लिए वह पोस्ट देखें। साकार करने के लिए @ torjanJohansen का धन्यवाद, मैं idकस्टम ऑपरेटर के बजाय चार बाइट बचा सकता था।

— dfeuer
स्रोत

idके बजाय इस्तेमाल किया जा सकता है !।

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

@ !RjanJohansen, हाँ वास्तव में! यह एक शांत चार बाइट्स बचाता है।

— दिफ़र

4

DeriveAnyClass, 104 बाइट्स

import Control.Exception
newtype M a=M a deriving(Show,Exception)
main=print.displayException$M Deadlock

इसे ऑनलाइन आज़माएं (बिना एक्सटेंशन के)

इसे ऑनलाइन आज़माएं (एक्सटेंशन के साथ)

की भी आवश्यकता है GeneralizedNewtypeDeriving।

— dfeuer
स्रोत

4

स्ट्रिक्टडाटा, 97 बाइट्स

import GHC.Generics
data A=A()deriving Generic
main=print$selDecidedStrictness$unM1.unM1$from$A()

इसे ऑनलाइन आज़माएं (कोई सख्त डेटा नहीं)

इसे ऑनलाइन आज़माएं (सख्त डेटा)

की भी आवश्यकता है DeriveGeneric।

— dfeuer
स्रोत

3

यूनिकोडसाइनटैक्स, 33 बाइट्स

(∀)=0
main|forall<-1=print(∀)

इसे ऑनलाइन आज़माएं!

— H.PWiz
स्रोत

3

TemplateHaskell, 140 91 बाइट्स

बस छोटे संशोधनों के साथ Mauke से कॉपी किया गया । मुझे नहीं पता कि क्या चल रहा है।

-49 बाइट्स थैंक्स टू अर्जन जोहान्सन।

import Language.Haskell.TH
instance Show(Q a)where show _=""
main=print$(pure$TupE[]::ExpQ)

इसे ऑनलाइन आज़माएं!

— stasoid
स्रोत

$(...)(कोई स्थान) TH के सक्षम होने पर टेम्प्लेट मूल्यांकन मूल्यांकन है, और TupE[]("खाली ट्यूपल") देता है ()। पॉलीग्लॉट के लिए अच्छी तरह से काम करShow सकता है, हालांकि इस विशेष चुनौती के लिए मुझे एक खाली स्ट्रिंग के रूप में प्रिंट करने के लिए एक मूल्य को परिभाषित करने के बारे में थोड़ा बुरा लगता है ...

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

2

मोनोमोर्फिस्मरट्रिशन, 31 29 बाइट्स

संपादित करें:

H.PWiz द्वारा एक सुधार के साथ -2 बाइट्स

f=(2^)
main=print$f$f(6::Int)

-XMonomorphismRestriction प्रिंट 0। -XNoMonomorphismRestriction प्रिंट 18446744073709551616।

प्रतिबंध के साथ, दो उपयोगों को fएक ही प्रकार के लिए मजबूर किया जाता है, इसलिए कार्यक्रम 2^2^6 = 2^6464-बिट Int(64-बिट प्लेटफॉर्म पर) के रूप में प्रिंट करता है , जो ओवरफ्लो करता है 0।
प्रतिबंध के बिना, कार्यक्रम 2^64एक बोली के रूप में प्रिंट करता है Integer।

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

1

मुझे लगता है f=(2^);main=print$f$f(64::Int)कि एक बाइट बच जाएगी। लेकिन यह वास्तविक रूप से समाप्त नहीं होगा

— H.PWiz

@ H.PWiz सौभाग्य से 64=2^6, जो अभी तक एक और बाइट बचाता है।

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

1

ScopedTypeVariables, 119 97 बाइट्स

बस मौक से नकल की छोटे संशोधनों के साथ ।

: इस समय वहाँ ScopedTypeVariables के लिए दो अन्य जवाब हैं सोंगोर चुंबन से 113 बाइट्स और dfeuer द्वारा 37 बाइट्स । यह सबमिशन इस मायने में अलग है कि इसमें अन्य हास्केल एक्सटेंशन की आवश्यकता नहीं है।

-22 बाइट्स थैंक्स टू अर्जन जोहान्सन।

class(Show a,Num a)=>S a where s::a->IO();s _=print$(id::a->a)0
instance S Float
main=s(0::Float)

इसे ऑनलाइन आज़माएं!

— stasoid
स्रोत

97 बाइट्स (हालांकि IO()/printचाल बहुभुज में काम नहीं करेगा)।

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

@ EdrjanJohansen मैंने ScopedTypeVariables जोड़ा, लेकिन ExtendedDefaultRules को तोड़ दिया । इसे कैसे तय किया जा सकता है? मुझे पहले से ही ऐसी त्रुटि थी, लेकिन मैं आपके स्पष्टीकरण को यहां लागू नहीं कर पा रहा हूं। ScopedTypeVariables कोड मैंने जोड़ा है यह है ।

— stasoid

मैं देखता हूं, कोड समान डिफ़ॉल्ट ट्रिक्स का उपयोग करते हैं, और वे एक दूसरे के साथ हस्तक्षेप करते हैं। एक समाधान यह है कि नए को एक अधिक प्रतिबंधित वर्ग का उपयोग करने दिया जाए Num। मुझे लगता है कि class(Show a,Floating a)=>K a where{k::a->String;k=pure$ show(f pi)where f=id::a->a};काम करना चाहिए, आसानी से इसका उपयोग करना चाहिए Floatऔर विभिन्न सटीकता के साथ Doubleप्रदर्शित करना चाहिए pi।

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

@ FitsrjanJohansen वाह, यह सही बैठता है। धन्यवाद।

— stasoid

रुको, यह कौन सी भाषा है?

नियम

भाषा एक्सटेंशन

स्कोरिंग

मैजिकहाश, 30 बाइट्स

सीपीपी, 33 20 बाइट्स

पिछले दृष्टिकोण के साथ #define

NumDecimals, 14 बाइट्स

बाइनरीलिटरल, 57 बाइट्स

मोनोमोर्फिस्मरट्रिशन + 7 अन्य, 107 बाइट्स

फ़ाइल T.hs, 81 + 4 बाइट्स

मुख्य, 22 बाइट्स

वैकल्पिक

ओवरलोडेडलिस्ट्स, 106 बाइट्स

ओवरलोडेड स्प्रिंग्स, 106 बाइट्स

PolyKinds, 112 बाइट्स

MonadComprehensions, 114 बाइट्स

NamedWildCards, 114 बाइट्स

एप्लीकेडो, 120 बाइट्स

ओवरलोडलेबल, 120 बाइट्स

सीपीपी, २ 25 २५

स्कोपेडाइपवियर्स, 162 113 बाइट्स

मोनोक्लोनलबाइंड, जीएडीटी या टाइपफैमिली, 36 32 बाइट्स

ओवरलोडेड स्प्रिंग्स, 65 48 32 बाइट्स

ओवरलोडेडलिस्ट्स, 27 बाइट्स

बैंगटैटन, 32 बाइट्स

एप्लीकेडो, 104 बाइट्स

सख्त, 87 84 82 बाइट्स

स्ट्रिक्टडाटा, 106 99 93 बाइट्स

एप्लीकेडो, 146 बाइट्स

बाइनरीलिटरल, 31 24 बाइट्स

ExtendedDefaultRules, 54 53 बाइट्स

रीबिंडेबल सिंथेट , 25 बाइट्स

सख्त, 52 बाइट्स

स्ट्रिक्टडाटा, 58 बाइट्स

व्याख्या

UnboxedTuples, 52 बाइट्स

ओवरलोडेडलिस्ट्स, 76 बाइट्स

HexFloatLiterals , 49 25 बाइट्स

ScopedTypeVariables, 37 बाइट्स

व्याख्या

DeriveAnyClass, 121 113 बाइट्स

PostfixOperators, 63 बाइट्स

DeriveAnyClass, 104 बाइट्स

स्ट्रिक्टडाटा, 97 बाइट्स

यूनिकोडसाइनटैक्स, 33 बाइट्स

TemplateHaskell, 140 91 बाइट्स

मोनोमोर्फिस्मरट्रिशन, 31 29 बाइट्स

ScopedTypeVariables, 119 97 बाइट्स

पिछले दृष्टिकोण के साथ `#define`