सिंटेक्स-चेकर को छोड़ें

Question

प्रस्तावना एक गूढ़ प्रोग्रामिंग भाषा है, जिसमें बहुत कम, लेकिन असामान्य है, जो एक वैध कार्यक्रम का गठन करता है। मुद्रण योग्य ASCII पाठ के किसी भी ब्लॉक ("ब्लॉक" का अर्थ है कि मुद्रण योग्य ASCII की पंक्तियों को नई लाइनों द्वारा अलग किया गया है - 0x0A) मान्य है:

• पाठ के प्रत्येक (लंबवत) कॉलम में सबसे अधिक (और एक पर होता है )।
• उनकी ऊर्ध्वाधर स्थिति को अनदेखा करते हुए, (और )संतुलित होते हैं, अर्थात, प्रत्येक को इसके दाईं ओर (एक के साथ जोड़ा जाता है ), और इसके विपरीत।

एक प्रोग्राम या फ़ंक्शन लिखें, जो मुद्रण योग्य ASCII और newlines से युक्त एक स्ट्रिंग दिया जाता है, यह निर्धारित करता है कि क्या यह एक वैध प्रस्ताव कार्यक्रम का गठन करता है। आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले सकते हैं। अपनी पसंद के किसी भी दो निश्चित सत्य / झूठे मूल्यों का उपयोग करके परिणाम को वापस या STDOUT पर मुद्रित किया जा सकता है ।

आपको यह नहीं मानना चाहिए कि इनपुट आयताकार है।

यह कोड गोल्फ है, इसलिए सबसे छोटा सबमिशन (बाइट्स में) जीतता है।

उदाहरण

निम्नलिखित मान्य प्रील्यूड प्रोग्राम हैं (वास्तव में, वे वास्तविक प्रील्यूड प्रोग्राम भी हैं):

?1-(v  #1)-             
1   0v ^(#    0)(1+0)#)!
    (#)  ^#1-(0 #       

1(#  1) v #  - 1+)
    vv (##^v^+
? v-(0 # ^   #)
?
  1+              1-!

और यहां बहुत सारे इनपुट हैं, जो सभी अमान्य हैं :

#(#(##)##)##(
)##(##(##)#)#

#(#)
)###

#(##
(##)

(##)
(#)#

(##)
(###

#(#)
(##)

#(#)
###)

#()#
()##

#(#)##
###
###(#)

Comments

क्या Prelude में ऐसी टिप्पणियां हैं जो किसी करीबी को रोक सकती हैं?

— एलेक्स ए।

@Alex No. उपरोक्त नियम वास्तव में सभी हैं, यह तय करने के लिए कि कोई कार्यक्रम वैध है या नहीं।

— मार्टिन एंडर

कूल, स्पष्ट करने के लिए धन्यवाद। बस सुनिश्चित करना चाहता था।

— एलेक्स ए।

नियम 1 - "पाठ के प्रत्येक स्तंभ में (और) के अधिकांश में शामिल हैं"; उदाहरण 1, पंक्ति 2: "1 0v ^ (# 0) (1 + 0) #)!" -> मैं 3 )और 2 देखता हूं (। यह केवल 1 प्रति पंक्ति नहीं होना चाहिए?

— इस्माईल मिगुएल

@IsmaelMiguel "कॉलम" को आमतौर पर ऊर्ध्वाधर लाइनों (विशेषकर ग्रिड के संदर्भ में) को संदर्भित करने के लिए समझा जाता है। मैंने इसे वैसे भी स्पष्ट किया है।

— मार्टिन एंडर

Answer 1

सीजेएम, 57 56 बाइट्स

qN/z_{_"()"--W<},,\s:Q,{)Q/({_')/,\'(/,-}:T~\sT0e>+z+}/!

बहुत लंबा, एक बहुत गोल्फ हो सकता है। एक बार इसे गोल्फ में शामिल करने के लिए स्पष्टीकरण।

संक्षिप्त विवरण

कोड में दो चेक हैं:

• पहला फ़िल्टर यह जाँचता है कि प्रत्येक कॉलम अधिकतम 1 ब्रैकेट में है। फ़िल्टर का अंतिम आउटपुट 1 से अधिक ब्रैकेट वाले कॉलम की संख्या है।
• दूसरा हम इनपुट को कॉलम प्रमुख प्रारूप में परिवर्तित करते हैं और फिर प्रत्येक इंडेक्स पर इसे दो भागों में विभाजित करते हैं।
  • इन दो भागों में, ( Number of "(" - Number of ")") एक दूसरे की प्रशंसा करनी चाहिए। इसलिए जब आप उन्हें जोड़ते हैं, तो इसका परिणाम 0. होना चाहिए। कोई भी हिस्सा जो इस संपत्ति को विफल करता है, पूरे इनपुट में गैर मिलान वाले ब्रैकेट हैं।
  • मुझे यह भी सुनिश्चित करना है कि "(" बाईं ओर ") हैं"। इसका मतलब यह है कि Number of "(" - Number of ")"सही साइड ब्लॉक के लिए मूल्य नकारात्मक नहीं हो सकता है।

इसे यहाँ ऑनलाइन आज़माएँ

Answer 2

पायथन 2, 128 119 105 बाइट्स

def F(p):
 v=n=1
 for r in map(None,*p.split("\n")):A,B=map(r.count,"()");n+=B-A;v*=n<2>A+B
 return n*v>0

क्या आप जानते हैं कि आप पायथन 2 में कोई नहीं कर सकते हैं ?

व्याख्या

हम प्रस्तावना ट्रांसपोज़ करके शुरू करना चाहते हैं ताकि कॉलम पंक्तियाँ बनें। आमतौर पर हम ऐसा करते हैं zip, लेकिन चूंकि zipयह सबसे छोटी पंक्ति की लंबाई के लिए छोटा होता है और itertools.zip_longestकोड-गोल्फ के लिए बहुत लंबा है, ऐसा लगता है कि जैसा हम चाहते हैं वैसा करने का कोई छोटा रास्ता नहीं है ...

मैपिंग को छोड़कर None:

>>> print map(None,*[[1,2,3],[4],[5,6]])
[(1, 4, 5), (2, None, 6), (3, None, None)]

दुर्भाग्य से (या बल्कि, सभी गैर-गोल्फ उद्देश्यों के लिए सौभाग्य से), यह केवल पायथन 2 में काम करता है।

के रूप में nऔर v:

• nस्टैक, गिनती की तरह कार्य करता है 1 - <number of unmatched '(' remaining>। प्रत्येक के लिए (हम देखते हैं कि हम 1 घटाते हैं, और प्रत्येक के लिए )हम देखते हैं कि हम 1 जोड़ते हैं। इसलिए यदि n >= 2किसी बिंदु पर है, तो हमने बहुत सारे देखे हैं )और कार्यक्रम अमान्य है। यदि n1 पर समाप्त नहीं होता है, तो हमारे पास कम से कम एक बेजोड़ (शेष है।
• vवैधता की जाँच करता है, और 1 से शुरू होता है। यदि कार्यक्रम कभी अमान्य ( n >= 2या A+B >= 2) है, तो vअमान्यता को चिह्नित करने के लिए 0 हो जाता है।

इसलिए यदि कार्यक्रम वैध है, तो अंत तक हमारे पास होना चाहिए n = 1, v = 1। यदि कार्यक्रम अमान्य है, तो अंत तक हमें या तो होना चाहिए v = 0, या v = 1, n <= 0। इसलिए वैधता को स्पष्ट रूप से व्यक्त किया जा सकता है n*v>0।

(अच्छे सुझावों के लिए @ बफ़र्स के लिए धन्यवाद जो 14 बाइट्स से दूर हुआ!)

पिछला, अधिक पठनीय सबमिशन:

def F(p):
 p=map(None,*p.split("\n"));v=n=0
 for r in p:R=r.count;A=R("(");B=R(")");n+=A-B;v|=A+B>1or n<0
 return n<1>v

Comments

यह एक पागल प्रयोग है map...

— xnor

119 -> 106def F(p): v=n=3 for r in map(None,*p.split("\n")):A,B=map(R.count,"()");n+=A-B;v*=n>2>A+B return n*v==9

— फ़र्सम

@ Faersum धन्यवाद! मैं परिवर्तित करने का प्रयास कर रहा था orतुलना श्रृंखलन में है, लेकिन मैं बदलने का नहीं सोचा था कि |=में *=। बंद एक और बाइट हालांकि ले लिया है, यहां तक कि चीजें बनाकर अधिक पीछे की ओर :)

— Sp3000

Answer 3

जे, 64 बाइट्स

इनपुट एक अनुगामी न्यूलाइन के साथ एक स्ट्रिंग है। आउटपुट 0 या 1 है।

(0=(1<|s)s+[:(|@{:+(0>])s)[:+/\]s=.+/@:)@(1 _1 0{~[:'()'&i.];.2)

उदाहरण उपयोग

   ]in=.'#(#)##',LF,'###',LF,'###(#)',LF
#(#)##
###
###(#)

   ((0=(1<|s)s+[:(|@{:+(0>])s)[:+/\]s=.+/@:)@(1 _1 0{~[:'()'&i.];.2)) in
0

विधि निम्नलिखित है

• newlines पर इनपुट में कटौती और एक मैट्रिक्स में डाल दिया ];.2
• नक्शा (/ )/ anything elseमें 1/ -1/0 1 _1 0{~[:'()'&i.]
• एक s=.+/@:क्रिया को परिभाषित करें जो एक क्रिया में जोड़ा जाता है जो क्रिया सरणी आउटपुट को दर्शाता है

• कॉलम में मान जोड़ें ]s

  • ()हर उपसर्ग में सकारात्मक संतुलन की जाँच करें[:(0>])s)[:+/\]
  • ()पूरी सूची में बराबर संतुलन की जाँच करें (यानी पिछले उपसर्ग में) |@{:@]

• कॉलम में एब्स (मान) जोड़ें और अधिकतम 1 के लिए प्रत्येक तत्व की जांच करें (1<|s)s

• पिछली सभी जाँचों में असफलता के साथ सकारात्मक परिणाम मिले हैं, हम उन्हें जोड़ते हैं और इनपुट की वैधता प्राप्त करने के लिए 0 से तुलना करते हैं 0=]

Answer 4

जे, 56 बाइट्स

3 :'*/0<: ::0:(+/\*:b),-.|b=.+/+.^:_1]0|:''()''=/];.2 y'

यह एक अनाम फ़ंक्शन है जो एक अनुगामी न्यूलाइन के साथ एक स्ट्रिंग को स्वीकार करता है और 0 या 1 लौटाता है। दाईं से बाईं ओर पढ़ना:

• ];.2 y, जैसा कि अन्य J सबमिशन में होता है, yअपने अंतिम चरित्र की सभी घटनाओं पर स्ट्रिंग को काट देता है (यही वजह है कि इनपुट को एक अनुगामी न्यूलाइन की आवश्यकता होती है) और एक आयताकार मैट्रिक्स बनाता है जिसकी पंक्तियाँ आवश्यक होने पर रिक्त स्थान के साथ गद्देदार होती हैं।

• '()'=/उस मैट्रिक्स में हर चरित्र की तुलना पहले (और फिर )दो 0-1 मैट्रिसेस की सूची के साथ की जाती है।

• +.^:_1]0|:दो मैट्रिक्स की उस सूची को जटिल संख्याओं के एकल मैट्रिक्स में बदल देता है। अब तक प्रोग्राम हर (इनपुट को 1 में बदल देता है , प्रत्येक )में i, और हर दूसरे वर्ण को 0 में बदल देता है।

• b=.+/उस जटिल मैट्रिक्स की पंक्तियों का योग प्रदान करता है b।

• -.|b1- की सूची बनाता है | z | में हर z के लिए b। अधिकांश एकल कोष्ठकों में प्रत्येक स्तंभ में होने वाली स्थिति इन सभी संख्याओं का अनुवाद करती है 1- | z | अप्रतिष्ठित होना।

• +/\*:bमें संख्याओं के वर्गों के चलने वाले रकम का वेक्टर है b। यदि प्रत्येक स्तंभ में अधिकतम एक कोष्ठक होता है, तो संख्याओं के वर्ग bसभी 0, 1 या -1 हैं। इस ,वेक्टर को 1-1; z | s के सदिश के साथ समेटता है।

• अब हम सभी को यह परखने की जरूरत है कि हमारे संघटित वेक्टर की प्रविष्टियाँ vnonngative reals संख्याएँ हैं, यह लगभग है */0<:v, सिवाय इसके कि यदि कुछ प्रविष्टियाँ vवास्तविक नहीं हैं, तो त्रुटि का कारण बनता है , इसलिए हम प्रतिस्थापित <:करते हैं, <: ::0:जिसमें त्रुटि के मामले में सिर्फ 0 वापस आता है ।

Comments

जटिल संख्या के साथ महान विचार लेकिन आपको यह भी जांचना होगा 0={:+/\*:bकि क्या उदाहरण (मान्य नहीं है।

— यादृच्छिक

ओह, तुम ठीक कह रहे हो, @randomra, मैं भूल गया!

— ओमर

0=(-|)vगैर-नकारात्मक वास्तविक की जाँच के लिए 2 बाइट्स छोटा है। (चलो CJam !: P) को हरा दें

— यादृच्छिक

ओह, और invइसके बजाय ^:_1 एक और बाइट बचाता है।

— रैंडम

56 पर वापस (बैलेंस चेकिंग के साथ) 3 :'*/0=({:,]-|)(-.@|,+/\@:*:)+/+.inv]0|:''()''=/];.2 y':।

— रैंडम