वह लगभग लिस्प है!

Question

चुनौती

आपकी चुनौती एक लिस्प जैसी भाषा के लिए दुभाषिया तैयार करना है, जो आगे से गढ़ा जाएगा: GLisp । GLisp के कार्यक्रम कोड में निम्न रूप में कोष्ठक द्वारा निरूपित नेस्टेड अभिव्यक्तियों की एक मनमानी राशि शामिल होगी:

(func arg1 arg2 ...)

ध्यान दें कि दुभाषिए को पहले और बाद में कोष्ठक, कार्यों और तर्कों के लिए बाहरी व्हाट्सएप वर्णों की अनुमति देनी चाहिए।

प्रकार

आप चार प्रकारों को लागू करेंगे, Integer, List, Boolean, और Function। पूर्णांक और बूलियन मान को स्पष्ट रूप से अपने स्वयं के सिंटैक्स के साथ स्रोत कोड में डाला जा सकता है। आपके दुभाषिया को यह मान लेना चाहिए कि संख्यात्मक वर्णों का एक भाग एक पूर्णांक को दर्शाता है (आपको नकारात्मक पूर्णांक डालने के लिए वाक्यविन्यास को लागू करने की आवश्यकता नहीं है)। आपके दुभाषिया को यह भी मानना ​​चाहिए कि trueऔर falseबूलियन मान निर्दिष्ट हैं। कार्यों को उपयोगकर्ता द्वारा स्पष्ट रूप से परिभाषित नहीं किया जा सकता है, और हमेशा एक ही मूल्य (किसी भी लम्बाई की सूची की एक एकल मान के रूप में) लौटाएगा।

कार्य

निम्नलिखित कार्यों को लागू करने की आवश्यकता है, और प्रारूप फ़ंक्शन , एरीटी में हैं । यदि किसी Arity nको एक धन चिह्न द्वारा आगे बढ़ाया जाता है, तो वह निरूपित करता है nया अधिक तर्क देता है। आप मान सकते हैं कि किसी फ़ंक्शन के लिए दिए गए सभी तर्क एक ही प्रकार के हैं, जब तक कि अन्यथा निर्दिष्ट न हो। आप यह भी मान सकते हैं कि यदि कोई व्यवहार किसी प्रमाणित प्रकार के लिए निर्दिष्ट नहीं है, तो आप मान सकते हैं कि उस फ़ंक्शन का कोई तर्क कभी भी उस प्रकार का नहीं होगा। निम्नलिखित आरेख में तर्क को संदर्भित किया जाएगा:

(func argument1 argument2 ... argumentn)

• + , 2+

  • यदि सभी तर्क पूर्णांक प्रकार के हैं , तो आपको तर्कों का योग वापस करना होगा
  • यदि सभी तर्क प्रकार सूची के हैं , तो आपको आरोही क्रम में तर्कों का संघटन वापस करना होगा ( arg1+arg2+ ...)
  • यदि सभी तर्क बूलियन प्रकार के हैं , तो आपको तर्क के अनुक्रम के तार्किक सभी को वापस करना होगा
  • (+ 1 2 3 4 5) -> 15
  • (+ (list 1 2) (list 3 4)) -> (list 1 2 3 4)
  • (+ true true true) -> true

• - , 2+

  • यदि सभी तर्क पूर्णांक प्रकार के हैं , तो आपको तर्कों के अंतर को वापस करना होगा ( arg1-arg2- ...)
  • यदि सभी तर्क बुलियन के प्रकार के हैं , तो आपको तर्क के किसी भी अनुक्रम को तार्किक वापस करना होगा
  • (- 8 4 3) -> 1
  • (- 0 123) -> -123
  • (- true false false true false) -> true

• * , 2+

  • यदि सभी तर्क टाइपर के हैं , तो आपको तर्कों के उत्पाद को लौटाना होगा
  • यदि एक तर्क प्रकार सूची का है और दूसरा प्रकार पूर्णांक का है (आप मान सकते हैं कि ये केवल दिए गए तर्क होंगे), आपको बार- बार मदों के साथ एक नई सूची वापस करनी होगी ।arg1arg2
  • (* 1 2 3 4 5) -> 120
  • (* (list 1 2 3) 2) -> (list 1 2 3 1 2 3)

• / , 2+

  • यदि सभी तर्क पूर्णांक प्रकार के हैं , तो आपको तर्कों का भाग वापस करना होगा ( arg/arg2/ ...) (आप मान सकते हैं कि विभाजन क्रमिक रूप से किया गया है, और यह कि हर चरण में दशमलव भाग छोटा है)
  • एक तर्क प्रकार का है, तो सूची और अन्य प्रकार की है समारोह , तो आप जिसके परिणामस्वरूप लौटना चाहिए सूची के बाद arg2हर मूल्य से अधिक मैप की गई है
  • (/ 100 10 3) -> 3
  • (/ (list 1 2 3) inc) -> (list 2 3 4)

• % , २

  • यदि सभी तर्क पूर्णांक प्रकार के हैं , तो आपको तर्कों के मापांक को वापस करना होगा
  • (% 4 2) -> 0

• = , 2+

  • यदि सभी तर्कों के प्रकार और मूल्य दोनों समान हैं, तो आपको सही लौटना चाहिए। नहीं तो झूठा लौट आता है।
  • (= 0 0 0) -> true
  • (= 0 false (list)) -> false

• सूची , 0+

  • आपको सभी तर्कों की सूची वापस करनी होगी, चाहे वह किसी भी प्रकार का हो। यदि कोई तर्क नहीं दिया जाता है, तो आपको एक खाली सूची वापस करनी होगी
  • (list 3 4 (list 5)) -> (list 3 4 (list 5))

• inc , १

  • यदि तर्क पूर्णांक प्रकार का है , तो आपको एक एक करके बढ़ाए गए पूर्णांक को वापस करना होगा
  • यदि तर्क प्रकार सूची का है , तो आपको सूची को एक बार में एक ही घुमाव पर घुमाया जाना चाहिए
  • (inc 1) -> 2
  • (inc (list 1 2 3)) -> (list 3 1 2)

• dec , १

  • यदि तर्क पूर्णांक प्रकार का है , तो आपको एक से घटे हुए पूर्णांक को वापस करना होगा
  • यदि तर्क प्रकार सूची का है , तो आपको सूची को घुमाए हुए काउंटर-क्लॉकवाइज़ को एक ही घुमाव पर वापस करना होगा
  • (dec 1) -> 0
  • (dec (list 1 2 3)) -> (list 2 3 1)

• यदि , ३

  • यदि किसी भी प्रकार के तीन तर्क दिए गए हैं : यदि सत्य का मूल्य सत्य arg1है arg2, तो वापस लौटेंarg3
  • (if (not (list 1)) 8 false) -> false

• नहीं , १

  • यदि किसी भी प्रकार का तर्क दिया जाता है, यदि सत्य का मूल्य arg1गलत है, तो वापस trueलौटें false।
  • (not (list)) -> true

• लेन , १

  • यदि टाइप सूची का तर्क दिया जाता है , तो लंबाई वापस कर देंarg1
  • (len (list 4 2 true (list 3) (list))) -> 5

सत्य तालिका: 0, (list), false -> falseजहां (list)एक खाली सूची को दर्शाता है। बाकी सब कुछ है true।

आपका दुभाषिया या तो एक पूर्ण प्रोग्राम हो सकता है जो स्टड या फ़ाइल से स्रोत इनपुट पढ़ता है, या एक फ़ंक्शन जो स्रोत को स्ट्रिंग के रूप में लेता है और आउटपुट मान देता है।

यदि पूर्व को चुनते हैं, तो इंटेगर के लिए आउटपुट बस संख्या है, बूलियंस के लिए trueया है false, और सूचियों के लिए कोष्ठक में संलग्न मूल्यों का एक अलग-अलग अनुक्रम है (उदाहरण। (1 2 3 4 (5 6 7))निरूपित (list 1 2 3 4 (list 5 6 7)))।

यदि उत्तरार्द्ध का चयन करते हैं, तो मूल्य को कार्यान्वयन भाषा के संगत प्रकार में लौटाया जाना चाहिए, या, यदि कोई समान प्रकार मौजूद नहीं है, तो एक कस्टम प्रकार। सूचियाँ यदि भाषा एक नहीं है सरणी या वाहक के रूप में वापस किया जा सकता सूची प्रकार, Booleans भाषा में एक बूलियन जैसे, या यदि भाषा उन्हें समर्थन नहीं करता है एक कस्टम प्रकार के रूप में किया जाना चाहिये।

परीक्षण के मामलों

(list 1 2 3 (list 4 5 true))  -> (1 2 3 (4 5 true))
(/ 4000 (+ 1 2 3 4 (* 5 8)))  -> 80
(+ (not (- (len (list 5 6 7)) (/ 10 3))) true)  -> true
(if (           len (list )  ) 4 (if    (+ (= 8 8    8) (not (list 4))) 8 5))  -> 5

स्पष्टीकरण

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

बोनस

• यदि आप आंशिक रूप से लागू किए गए कार्यों का समर्थन करते हैं, तो स्कोर * 0.8 । उदाहरण के लिए, के ((+ 2) 3)रूप में ही होगा (+ 2 3), लेकिन इस तरह की चीजों के लिए अनुमति देता है (/ (list 1 2 3) (+ 2))। आप मान सकते हैं कि किसी फ़ंक्शन को आंशिक रूप से लागू किया जाता है यदि वह अपने न्यूनतम तर्कों से कम प्राप्त करता है
• स्कोर * 0.85 यदि आप लागू तर्कों का मूल्यांकन नहीं ifकरते हैं जब तक कि उन्हें वापस नहीं किया जाएगा

यह कोड-गोल्फ है, इसलिए सबसे कम बाइट गिनती जीत के साथ दुभाषिया है!

Comments

कोई कैसे व्याख्या करता है (if (not (array 1)) 8 false) -> false?

— feersum

@ फेरेसम अच्छा कैच, माना जाता है 8.

— ग्लोबबी

हमें कैसे मूल्यांकन करना चाहिए (+ 3 (if false 5))? आम तौर पर बोल, "वास्तव में कुछ भी नहीं लौट रहा है" क्या है? आपने किसी भी प्रकार के यूनिट को फिर से निर्दिष्ट नहीं किया

— गर्वित हैकेलर

1. क्यों (+ bool bool...)तार्किक और (- bool bool...)तार्किक है या? मानक रिंग नोटेशन +OR और *AND के लिए उपयोग करेगा । 2. क्या "अमान्य इनपुट" ऐसे मामलों को कवर करने का इरादा है, (/ 2 0)जो वाक्य-रचना सही हैं? 3. =यदि मान सभी समान नहीं हैं, तो क्या यह वापस आ जाना चाहिए false? 4. notप्रकट होने की परिभाषा पीछे की ओर है। 5. टोकन क्या हैं? आप कहते हैं कि दुभाषिया को अतिरिक्त व्हाट्सएप को संभालना होगा, लेकिन आप यह नहीं कहते कि यह किस व्हाट्सएप पर भरोसा कर सकता है। इस तरह के जटिल प्रश्नों के लिए, आपको वास्तव में सैंडबॉक्स का उपयोग करना चाहिए ताकि कल्पना की जा सके।

— पीटर टेलर

यह स्पष्ट नहीं है कि आंशिक आवेदन कैसे काम करना चाहिए: एक त्रुटि के ((+ 2 3) 4)बराबर है 9या नहीं? विशेष रूप से, var-arg फ़ंक्शन के लिए, यह स्पष्ट नहीं है कि किसी को आवेदन को आंशिक कैसे माना जाना चाहिए। यहां तक ​​कि चीजों के साथ भी ((if true (+ 2 3) (- 5)) 4)

— मुडियार

Answer 1

हास्केल, 1370 1263 1179 1128 1163 1107 1084 बाइट्स * 0.8 * 0.85 = 737.12

import Text.Parsec
data V=I Int|L[V]|T|F|P[V]|X|A|S|M|D|U|E|Q|J|K|C|N|W deriving Eq
m Q=0;m C=3;m f|f`elem`[J,K,N,W]=1;m _=2
l=length
x v=[n|I n<-v]
y v=[l|L l<-v]
z v=[0<1|T<-v]++[1<0|F<-v]
(&)f=l.f>>=(.l).(==)
b a|a=T|0<1=F
s(I n)=show n
s(L v)='(':tail(v>>=(' ':).s)++")"
s T=d!!0;s F=d!!1;s _="error"
i(L v)=e$i%v
i v=v
e(P v:a)=e$v++a
e(f:a)|m f>l a=P(f:a)
e(A:a)|x&a=I$sum$x a|y&a=L$concat$y a|z&a=b$and$z a
e(S:a)|x&a=I$f$x a|z&a=b$or$z a
e(M:a)|x&a=I$product$x a
e[M,v,I n]=e$A:replicate n v
e(D:a)|x&a=I$v$x a
e[D,L v,f]=L$map(\a->e[f,a])v
e[U,I a,I b]=I$a`mod`b
e(E:a:v)=b$all(==a)v
e(Q:a)=L a
e[J,I a]=I$a+1
e[J,L[]]=L[]
e[J,L v]=L$last v:init v
e[K,I a]=I$a-1
e[K,L v]=L$drop 1 v++take 1 v
e[C,a,b,c]|a`elem`[I 0,L[],F]=c|0<1=b
e[N,a]=e[C,a,F,T]
e[W,L v]=I$l v
e _=X
f(a:b)=a-sum b
v(a:b)=foldl div a b
(%)f=fmap f
p=k$choice$try%([(I .read)%many1 digit,L%between(w"(")(k$w")")(many$try p)]++zipWith((.return).(>>).w)d[T,F,A,S,M,D,U,E,Q,J,K,C,N,W])
k=(spaces>>)
w=string
d=words"true false + - * / % = list inc dec if not len"
g=either show(s.i).parse p""
main=interact g

पूरा कार्यक्रम, पढ़ने stdinऔर लिखने के लिए stdout। gफ़ंक्शन संस्करण है, साथ ही।

आंशिक कार्य, और आलसी मूल्यांकन दोनों के कार्यान्वयन if।

नमूना रन (फ़ंक्शन संस्करण का):

λ: g "(list 1 2 3 (list 4 5 true))"
(1 2 3 (4 5 true))

λ: g "(/ 4000 (+ 1 2 3 4 (* 5 8)))"
80

λ: g "(+ (not (- (len (list 5 6 7)) (/ 10 3))) true)"
true

λ: g "(if (           len (list )  ) 4 (if    (+ (= 8 8    8) (not (list 4))) 8 5))"
5

λ: g "(if false (/ 1 0) 5)"
5

λ: g "((+ 2) 3)"
5

λ: g "(/ (list 1 2 3) (+ 2))"
(3 4 5)

अब विवरण से सभी यूनिट परीक्षण हैं:

λ: runTests 
passed: g "(+ 1 2 3 4 5)" ==> 15
passed: g "(+ (list 1 2) (list 3 4))" ==> (1 2 3 4)
passed: g "(+ true true true)" ==> true
passed: g "(- 8 4 3)" ==> 1
passed: g "(- 0 123)" ==> -123
passed: g "(- true false false true false)" ==> true
passed: g "(* 1 2 3 4 5)" ==> 120
passed: g "(* (list 1 2 3) 2)" ==> (1 2 3 1 2 3)
passed: g "(/ 100 10 3)" ==> 3
passed: g "(/ (list 1 2 3) inc)" ==> (2 3 4)
passed: g "(% 4 2)" ==> 0
passed: g "(= 0 0 0)" ==> true
passed: g "(= 0 false (list))" ==> false
passed: g "(list 3 4 (list 5))" ==> (3 4 (5))
passed: g "(inc 1)" ==> 2
passed: g "(inc (list 1 2 3))" ==> (3 1 2)
passed: g "(dec 1)" ==> 0
passed: g "(dec (list 1 2 3))" ==> (2 3 1)
passed: g "(if (not (list 1)) 8 9)" ==> 9
passed: g "(not (list))" ==> true
passed: g "(len (list 4 2 true (list 3) (list)))" ==> 5
passed: g "(list 1 2 3 (list 4 5 true))" ==> (1 2 3 (4 5 true))
passed: g "(/ 4000 (+ 1 2 3 4 (* 5 8)))" ==> 80
passed: g "(+ (not (- (len (list 5 6 7)) (/ 10 3))) true)" ==> true
passed: g "(if (           len (list )  ) 4 (if    (+ (= 8 8    8) (not (list 4))) 8 5))" ==> 5
passed: g "(if false (/ 1 0) 5)" ==> 5
passed: g "((+ 2) 3)" ==> 5
passed: g "(/ (list 1 2 3) (+ 2))" ==> (3 4 5)

Comments

b ऐसे मामले जिन्हें e[K,L _]आप drop 1 एक सुरक्षित संस्करण के रूप में उपयोग कर सकते हैं tailऔर takeसुरक्षित headपरिभाषा के लिए उपयोग कर सकते हैंe[K,L _]

— गर्व हैकेलर की

आप समारोह का उपयोग कर सकते notElem.another टिप: आप कर सकते हैं s=stringऔर इसके बजाय दोनों के लिए इसका इस्तेमाल stringऔर char( s"C"बनाम char 'C')। एक और टिप: if

— गर्व हैस्केलर

एक और बात जो मैंने सोची थी: आप Maybeसूचियों द्वारा मान को सांकेतिक शब्दों में बदल सकते हैं । Nothingहै []और Just xहै [x]। यह लंबे कंस्ट्रक्टरों से छुटकारा दिलाता है और कुछ और कार्यात्मकताएं जोड़ता है: if p then Just x else Nothingहै [x|p], (==Nothing)है null, लिस्ट मोनड हो सकता है कि शायद मोनाड, और इसी तरह आगे।

— गर्वित हैकेलर

@proudhaskeller धन्यवाद, सभी ने आवेदन किया!

— माउंटन व्यूमार्क 15

Answer 2

पायथन 2, 1417 * 0.8 * 0.85 = 963.56

from operator import*
A=type;K="list"
def E():print"E";exit()
def R(G):
 len(G)or E();T=G.pop(0);L=[]
 if"("==T:
  G or E()
  while")"!=G[0]:L+=[R(G)];G or E()
  G.pop(0);return L
 if")"==T:E()
 try:
  x=eval(T.title())
  if Q(x)<2:return x
  E()
 except:return T
H="+ - * / = % if inc dec not len"
Z=lambda y:lambda x:reduce(y,x)
D=dict(zip(H.split(),[[sum,any,0,lambda x:sum((y[1:]for y in x),[K])],[Z(sub)],[Z(mul),all,0,lambda x:x[0][:1]+x[0][1:]*x[1]],[Z(div),lambda x:[K]+map(lambda z:S([x[1],z]if Q(x[1])==2else x[1]+[z]),x[0][1:])],[lambda x:len(set(map(str,x)))<2]*6,[lambda x:x[0]%x[1]],[lambda x:S(x[2])if S(x[0])in[0,[K]]else S(x[1])]*6,[lambda x:x[0]+1,0,0,lambda x:x[0][:1]+x[0][-1:]+x[0][1:-1]],[lambda x:x[0]-1,0,0,lambda x:x[0][:1]+x[0][2:]+[x[0][1]]],[lambda x:x[0]in[0,[K]]]*6,[0]*3+[lambda x:len(x)-1]]))
H=H[:15]+H+" if"
def Q(x):
 t=A(x);w=int,bool,str
 if t in w:return w.index(t)
 if t==list and x:return 5-(2*(x[0]==K)+(str==A(x[0])and len(x)<H.count(x[0])+1))
 E()
def S(G):
 if Q(G)<2:return G
 G or E();c=G[0];r=G[1:];c==K or r or E()
 if c!="if":r=[x if Q(x)in{2,4}else S(x)for x in r]
 if c==K:return[c]+r
 k=map(Q,r);m=min(k);M=max(k);v=[m,[-1,3][{m,M}=={4,5}]][m!=M]
 try:return D[c][v](r)
 except:E()
def C(x):return"(%s)"%" ".join(map(C,x))if A(x)==list else str(x).lower()
def I(G):
 for c in"+-*/%=()":G=G.replace(c," %s "%c)
 return C(S(R(G.strip().split())))
print I(raw_input())

पूरा ओवरहाल। यदि आप पिछले संस्करण देखना चाहते हैं, तो संपादन इतिहास देखें ।

वहाँ बहुत कुछ और गोल्फ हो रहा है। मैं धीरे-धीरे इस पर काम कर रहा हूं।

Zlib / base64 के साथ हमें 1093 * 0.8 * 0.85 = 743.24 मिलते हैं :

import base64,zlib
exec zlib.decompress(base64.b64decode("eJx9VE1P4zAQvedXGEuV7MbttgX2kOADAtSugANbTljWKqSuNku+5Lg0BfHfd8ZJCwjt9tLpdN6bmTczXtuqIFVtbOIqS7KirqwbBufS7WoTX0uaZ42jwcqsyRXjUW2z0tErGps2c4x7/08251FAclOCARwQF9/L+biuajbh8Y1UOiDZmjIq5T0EkjnposDc/s5yQzk9knM10dFNKBXS6fhDzIHJGrexJbnxbNyz+Qhnd0jbSvOc5Ox+7DKXG8YRm63JHWv52SzqwS04Pci0qand3n0fLCQNyYgMyTciyQCBWZmSlUlJWTlsjgYPMk+Kx1VCdlFvtIBfbVLDdqLlwaVcZaljL1nNFuOmzlEhoVSzKURS7sREHFDgYmynppFeQ5s7SEVaCL3WXAv1wJrNY2cUm5yLJM8/YlsQSkVTHXoDKIatmmofvsqe+Xsg0IVFUrPe8RItmcJQ8aI7WcDmUs5M3hiCP0L1ornY02IFBy4cbmMcQ77GWeiWg6h6+P1DDAIHfS0H5xLSzDSHhGhNwCrVBDvVPu2yq+IrUTiFnv/Z9Qjq2/c/+pwQvaP/gmeAVR1Yf4EeyvMlTfTwOPysQssxISzXQi6A81SHi5DiQvpbwGWDXXTyHIx4K+FaxGNV5QJEw7UlDme93a/ddpyVK9Myx7s/pcRzI0m58qvlY05HbDb02kl5zUOUXyI9iomBXVFni3FabUrX+cMpbv9Vf6DL7kD90OcfbmEeHE4xTv0Bxha+QFv4Ka/xL3s4Q0CnR5JCo5GVqt1fVla+zsTJ236YHPe5xR6t7jBA1OdTqQ5BhCeJS3QnLI8LWWQle+LxLfhaNJ6lKgSMVxxr9VqI2zcpX0/E6ZvWqjiSt7o79r7+S2BUz5rZ93Pet3yBc+jCKBs0nA4ooeM/FaTD7Be4wFAdTqnX3HcA2oJnnFdbY3umH5142FcKfdFwNPw2kIzTaA5vnDV1nsD9p4KSQUPoIIVa+vIu2JLBYzYGUngR+P5FgE/gn1Ggtsn2V1bWG3T/BUW+qRU="))

नोट: यदि आप मेरे स्कोर को ऊपर जाते हुए देखते हैं, तो यह शायद इसलिए है क्योंकि मुझे कुछ कीड़े मिले हैं

Comments

एक कोड गोल्फ की तुलना में कोड चुनौती का अधिक लेकिन फिर भी, 4872 * 0.8 = 3897,6

— Def

Answer 3

आम लिस्प, 868 बाइट्स * 0.85 = 737.8

क्या लिस्प के साथ लिस्प को लागू करना धोखा है? अभी भी यहाँ अनुकूलन करने के लिए बहुत कुछ।

(SETF (READTABLE-CASE *READTABLE*) :PRESERVE)(PRINC(LABELS((B(X)(FIND X'(true false)))(R(X)(IF X'true'false))(V(X)(MEMBER X'(0()false)))(A(&REST X)(R(NOTANY #'V X)))(O(&REST X)(R(NOTEVERY #'V X)))(E(X &KEY N)(IF(LISTP X)(ECASE(FIRST X)(+(APPLY(IF(EVERY'NUMBERP #1=(MAPCAR(IF N #'IDENTITY #'E)(CDR X)))'+(IF(EVERY'LISTP #1#)'APPEND #'A))#1#))(-(APPLY(IF(EVERY'NUMBERP #1#)'- #'O)#1#))(*(IF(LISTP #2=(CAR #1#))(LOOP FOR I TO(1-(CADR #1#))APPEND #2#)(APPLY'* #1#)))(/(IF(LISTP #2#)(LOOP FOR I IN #2#COLLECT(E `(,(CADR #1#),I):N T))(REDUCE'FLOOR #1#)))(%(APPLY'MOD #1#))(=(R(LOOP FOR I IN(CDR #1#)ALWAYS(EQUAL I #2#))))(list #1#)(inc(IF(LISTP #2#)(APPEND(LAST #2#)(BUTLAST #2#))(1+ #2#)))(dec(IF(LISTP #2#)(APPEND(CDR #2#)`(,(FIRST #2#)))(1- #2#)))(if(IF(V(E(CADR X)))(E(CADDDR X))(E(CADDR X))))(not(R(V #2#)))(len(LENGTH #2#)))X)))(OR(IGNORE-ERRORS(OR(E(READ))"()")):E))

इनपुट में त्रुटि के मामले में एक ई प्रिंट करता है। नमूना चलता है:

$ sbcl --script glisp.lisp
(list 1 2 3 (list 4 5 true))
(1 2 3 (4 5 true))

$ sbcl --script glisp.lisp
(/ 4000 (+ 1 2 3 4 (* 5 8)))
80

$ sbcl --script glisp.lisp
(+ (not (- (len (list 5 6 7)) (/ 10 3))) true)
true

$ sbcl --script glisp.lisp
(if (           len (list )  ) 4 (if    (+ (= 8 8    8) (not (list 4))) 8 5))
5

$ sbcl --script glisp.lisp
(this is an error)
E

$ sbcl --script glisp.lisp
(if (% 4 2) (this is an error) 42)
42

Comments

जब तक यह एक प्रकार का निष्कासन कार्य नहीं है ...

— Def

Answer 4

हास्केल, 972

r=fst.f
f('(':s)|(f:a,b)<-g s=(f%filter(/="")a,b)
f s=span(`notElem`" ()")s
j=dropWhile(==' ')
g""=([],"")
g s|')':l<-r=([x],l)|(y,t)<-g$j r=(x:y,t)where(x,r)=f$j s
"%"%c=show$foldr(mod.read)(maxBound::Int)c
"+"%c|t(c!!0)<1="(list "++tail(c>>=(' ':).drop 6.init)++")"|t(c!!0)<2=show$sum$map read c|0<1=i$all((=='t').head)c
"-"%c|t(c!!0)<2=show$foldl1(-)$map read c|0<1=i$any((=='t').head)c
"*"%c=fst$f$"(+ "++unwords([1..read$last c]>>init c)++")"
"="%c=i$all(==c!!0)c
"/"%c|t(c!!0)<1,[a,b]<-c="list"%map(\x->b%[x])(fst$g$drop 6 a)|0<1=show$foldl1 div$map read c
"if"%[p,a,b]|elem p["0","()","false"]=b|0<1=a
"list"%c="(list "++unwords c++")"
"len"%[c]=show$length(words c)-1
"inc"%[c]|t c>0=show$read c+1|([],_)<-g$drop 6 c="(list)"|(x,_)<-g$drop 6 c="list"%(last x:init x)
"dec"%[c]|t c<1,(x,_)<-g$drop 6 c="list"%(drop 1 x++take 1 x)|0<1=show$read c-1
"not"%[c]="if"%[c,"false","true"]
s%c="?"
i p|p="true"|0<1="false"
t('(':_)=0
t(c:s)|c<':',c>'/'=1|elem c"th"=2
t _=3

काफी हैसी समाधान। यह सब कुछ आउटपुट-तैयार रूप में स्ट्रिंग्स के रूप में संग्रहीत करता है - उनके प्रकारों को उनके पहले अक्षर - 0..9नंबरों के लिए, (सूचियों के लिए, tया fबूलियन के लिए, और फ़ंक्शंस के लिए सब कुछ अलग किया जा सकता है।

rसमारोह का उपयोग करने के लिए चलाने के लिए ।