लोकप्रिय और (और आवश्यक) कंप्यूटर विज्ञान की किताब, पीटर लिन्ज़ द्वारा औपचारिक भाषाओं और ऑटोमेटा का एक परिचय , निम्नलिखित औपचारिक भाषा अक्सर कहा जाता है:

परिभाषा

मुख्य रूप से क्योंकि इस भाषा को परिमित-राज्य ऑटोमेटा के साथ संसाधित नहीं किया जा सकता है। इस अभिव्यक्ति का अर्थ है "भाषा एल में 'के बाद के सभी तार शामिल हैं' के बाद, जिसमें 'ए और' बी की संख्या बराबर और गैर-शून्य हैं"।

चुनौती

एक कार्यशील प्रोग्राम / फ़ंक्शन लिखें, जो एक स्ट्रिंग प्राप्त करता है, जिसमें केवल "s" और "b" s होता है , क्योंकि इनपुट और रिटर्न / एक सत्य मान आउटपुट करता है , यह कहते हुए कि क्या यह स्ट्रिंग औपचारिक भाषा एल है।

आपका प्रोग्राम किसी भी बाह्य संगणना उपकरण का उपयोग नहीं कर सकता है, जिसमें नेटवर्क, बाहरी कार्यक्रम आदि शामिल हैं। शेल इस नियम का एक अपवाद हैं; बैश, उदाहरण के लिए, कमांड लाइन उपयोगिताओं का उपयोग कर सकते हैं।
आपके कार्यक्रम को परिणाम "तार्किक" तरीके से वापस करना / आउटपुट करना चाहिए, उदाहरण के लिए: 0 के बजाय 10 वापस करना, "बीप" ध्वनि, स्टडआउट के लिए आउटपुट आदि अधिक जानकारी यहां।
मानक कोड गोल्फ नियम लागू होते हैं।

यह एक कोड-गोल्फ है । बाइट्स में सबसे छोटा कोड जीतता है। सौभाग्य!

सत्य परीक्षण के मामले

"ab"
"aabb"
"aaabbb"
"aaaabbbb"
"aaaaabbbbb"
"aaaaaabbbbbb"

झूठे परीक्षण के मामले

""
"a"
"b"
"aa"
"ba"
"bb"
"aaa"
"aab"
"aba"
"abb"
"baa"
"bab"
"bba"
"bbb"
"aaaa"
"aaab"
"aaba"
"abaa"
"abab"
"abba"
"abbb"
"baaa"
"baab"
"baba"
"babb"
"bbaa"
"bbab"
"bbba"
"bbbb"

— समुदाय
स्रोत

24

क्या इनपुट खाली हो सकता है? (आप कह रहे हैं कि यह भाषा का हिस्सा नहीं है, लेकिन ऐसा नहीं है कि यह एक ऐसा इनपुट है जिस पर हमें विचार करने की आवश्यकता है।)

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

1

अगर हमारी भाषा में सच्चाई या झूठ नहीं है तो क्या होगा? चाहेंगे empty string == truthyऔर non-empty string == falsyस्वीकार्य हो?

— DJMcMayhem

5

अच्छी चुनौती है, लेकिन मुझे लगता है कि शीर्षक थोड़ा कम अस्पष्ट हो सकता है (यानी a^n b^nकेवल एस की संख्या के aबराबर संख्या के बजाय या इसी तरह का उल्लेख b)

— Sp3000

1

@ Sp3000 मैंने इस शीर्षक को चुना क्योंकि यह मजेदार लग रहा था। मैं इसे बाद में sth में बदल सकता हूँ ...

1

मुझे थोड़ी हैरानी हुई कि 50+ जवाबों में मैं केवल एक ही जनरेटर का उपयोग कर रहा हूं। यह सुनिश्चित करने के लिए कि यह लंबाई पर कड़ाई से प्रतिस्पर्धी नहीं है, लेकिन समस्या का हल एक सरल, लेकिन गैर-तुच्छ भाषा है। मैं अन्य कंपाइलर-कंपाइलर सिंटैक्स में जवाब देखना पसंद करता हूं क्योंकि मैं विकल्पों से व्यापक रूप से परिचित नहीं हूं।

— dmckee

34

MATL , 5 4 बाइट्स

tSP-

की एक गैर खाली सरणी प्रिंट करता है 1 रों यदि स्ट्रिंग के अंतर्गत आता है एल , और एक खाली सरणी या के साथ एक सरणी 0 एस (दोनों falsy) अन्यथा।

1 बाइट को बंद करने के लिए @LuisMendo का शुक्रिया!

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

यह काम किस प्रकार करता है

t      Push a copy of the implicitly read input.
 S     Sort the copy.
  P    Reverse the sorted copy.
   -   Take the difference of the code point of the corresponding characters
       of the sorted string and the original.

— डेनिस
स्रोत

6

मेरा दूसरा (काम कर) MATL उत्तर। :)

— डेनिस

2

सत्य और असत्य की अजीब परिभाषा: 'आब' देता है -1 -1 1 1 सत्य है। 'आबब' -1 -1 0 1 1 देता है और

— झूठा है

3

@Etoplay अपने सभी मूल्यों के साथ एक गैर-खाली सरणी है जो नॉनजरो सत्य है। यह Matlab और ऑक्टेव में इस्तेमाल की जाने वाली परिभाषा है

— लुइस मेंडू

145

पायथन 3, 32 बाइट्स

eval(input().translate(")("*50))

निकास कोड के माध्यम से आउटपुट : गलत के लिए त्रुटि, ट्रू के लिए कोई त्रुटि नहीं।

स्ट्रिंग का मूल्यांकन पायथन कोड के रूप में किया जाता है, जिसके (लिए aऔर इसके )लिए पार्न्स की जगह ली जाती है b। केवल रूप की अभिव्यक्तियाँ a^n b^nकोष्ठकों की अच्छी तरह से निर्मित अभिव्यक्तियाँ बन जाती हैं ((())), जैसे कि टपल का मूल्यांकन ()।

कोई भी बेमेल पारेंस एक त्रुटि देता है, जैसे कि कई समूह होंगे (()()), क्योंकि कोई विभाजक नहीं है। खाली स्ट्रिंग भी विफल हो जाती है (यह सफल होगा exec)।

रूपांतरण ( -> a, ) -> bका उपयोग करके किया जाता है str.translate, जो वर्णों को एक स्ट्रिंग द्वारा इंगित के रूप में प्रतिस्थापित करता है जो रूपांतरण तालिका के रूप में कार्य करता है। 100-लंबाई स्ट्रिंग को देखते हुए ") (" * 50 ", तालिकाएँ पहले 100 ASCII मानों के रूप में मैप करती हैं

... Z[\]^_`abc
... )()()()()(

जो लेता है ( -> a, ) -> b। पायथन 2 में, सभी 256 ASCII मूल्यों के लिए रूपांतरण प्रदान किए जाने चाहिए "ab"*128, एक बाइट की आवश्यकता होती है; यह इंगित करने के लिए isaacg का धन्यवाद।

— XNOR
स्रोत

58

ठीक है, वह चतुर है।

— टीएलडब्ल्यू

क्या करता *128है?

— 22:22 पर आउटगॉल्फ जूल को एरिक

5

128एक बाइट को बचाने के लिए 50(या 99उस मामले के लिए) द्वारा प्रतिस्थापित किया जा सकता है ।

— isaacg

@ E @ ʀɪᴋ Gᴏʟғᴇʀ: मुझे लगता है कि यह क्वांटिफायर है। लेकिन मैं वास्तव में अजगर को नहीं जानता और उस पर अभी तक कोई दस्तावेज नहीं मिला है।

— टाइटस

4

@isaacg धन्यवाद, मुझे पता नहीं था कि पायथन 3 के लिए बदल गया है।

— xnor

28

रेटिना , 12 बाइट्स

श्रेय FryAmTheEggman को मिला जिन्होंने इस समाधान को स्वतंत्र रूप से पाया।

+`a;?b
;
^;$

1मान्य इनपुट के लिए प्रिंट और 0अन्यथा।

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

व्याख्या

बैलेंसिंग समूहों को महंगे सिंटैक्स की आवश्यकता होती है, इसलिए इसके बजाय मैं एक साधारण फॉर्म के लिए एक वैध इनपुट को कम करने की कोशिश कर रहा हूं।

चरण 1

+`a;?b
;

+रेटिना बताता है जब तक उत्पादन बदल रहा बंद हो जाता है एक पाश में इस स्तर को दोहराने के लिए। यह abया तो मेल खाता है या a;bइसके साथ बदलता है ;। आइए कुछ मामलों पर विचार करें:

यदि स्ट्रिंग में as और bs एक ही तरह से संतुलित नहीं हैं, (और )आम तौर पर होने की जरूरत है, कुछ aया bस्ट्रिंग में रहेगा, के बाद से ba, या b;aहल नहीं किया जा सकता है और एक aया bअपने दम पर नहीं कर सकते या तो। सभी aएस और एस से छुटकारा पाने के लिए प्रत्येक के दाईं ओर bएक होना चाहिए ।ba
यदि aऔर bसभी नेस्टेड नहीं हैं (जैसे अगर हमारे पास कुछ है ababया aabaabbb) तो हम कई के साथ समाप्त हो जाएंगे ;(और संभवतः कुछ aएस और bएस) क्योंकि पहला पुनरावृत्ति कई abएस को उन्हें सम्मिलित करने के लिए मिलेगा और आगे पुनरावृत्तियों को संरक्षित करेगा। ;स्ट्रिंग में संख्या ।

इसलिए, यदि और केवल यदि इनपुट फॉर्म का है , तो हम स्ट्रिंग में एकल के साथ समाप्त करेंगे ।aⁿbⁿ;

चरण 2:

^;$

जांचें कि क्या परिणामी स्ट्रिंग में एकल अर्धविराम के अलावा कुछ नहीं है। (जब मैं "चेक" कहता हूं तो मेरा वास्तव में मतलब है, "दिए गए रेगेक्स के मैचों की संख्या को गिनें, लेकिन चूंकि रेगेक्स एंकरों के कारण सबसे अधिक बार मेल कर सकता है, यह 0या तो देता है 1।)

— मार्टिन एंडर
स्रोत

25

हास्केल, 31 बाइट्स

f s=s==[c|c<-"ab",'a'<-s]&&s>""

सूची की समझ प्रत्येक में [c|c<-"ab",'a'<-s]एक के 'a'लिए एक स्ट्रिंग बनाती है , उसके बाद प्रत्येक में एक के लिए । यह एक स्थिर पर मिलान और प्रत्येक मैच के लिए एक आउटपुट का उत्पादन करके गिनती से बचा जाता है ।'a's'b''a's

यह स्ट्रिंग मूल स्ट्रिंग के बराबर होने के लिए जाँच की जाती है, और मूल स्ट्रिंग को गैर-रिक्त होने के लिए जाँच की जाती है।

— XNOR
स्रोत

ये बहुत प्यारी है। मैं अक्सर भूल जाता हूं कि यह कितना उपयोगी है कि हास्केल सूची के तत्वों को सुसंगत और बहुत विशिष्ट तरीके से आदेश देता है।

— वेक्टोर्नट

मेरे सबसे अच्छे प्रयास की तुलना में बहुत अच्छा है ( f=g.span id.map(=='a');g(a,b)=or a&&b==(not<$>a))। बहुत बढ़िया।

— जूल्स

वाह, मुझे नहीं पता था कि कोई एक सूची में एक निरंतरता पर मेल खा सकता है!

— रूबिक

16

पीस , 12 बाइट्स

A=\aA?\b
e`A

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

व्याख्या

पहली पंक्ति एक नॉनटर्मिनल को परिभाषित करती है A, जो एक अक्षर से मेल खाती है a, संभवतः नॉनटर्मिनल Aऔर फिर एक अक्षर से b। दूसरी लाइन eनॉनटर्मिनल के खिलाफ पूरे इनपुट ( ) से मेल खाती है A।

8-बाइट नॉनकंपेटिंग संस्करण

e`\a_?\b

इस उत्तर के पहले संस्करण को लिखने के बाद, मैंने _शीर्ष-स्तरीय अभिव्यक्ति के नाम के रूप में विचार करने के लिए Grime को अपडेट किया । यह समाधान उपरोक्त के बराबर है, लेकिन लेबल को दोहराने से बचा जाता है A।

— Zgarb
स्रोत

आपने इसे J में क्यों नहीं किया?

— लीक नन

@LeakyNun मैं सिर्फ ग्रीम दिखाना चाहता था। : पी

— ज़गर्ब

आपने यह भाषा बनाई है?

— लीक नन

@LeakyNun हां। विकास धीमा है, लेकिन जारी है।

— जर्बेर जूल

11

ब्रेकीलॉग , 23 19 बाइट्स

@2L,?lye:"ab"rz:jaL

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

व्याख्या

@2L,                  Split the input in two, the list containing the two halves is L
    ?lye              Take a number I between 0 and the length of the input              
        :"ab"rz       Zip the string "ab" with that number, resulting in [["a":I]:["b":I]]
               :jaL   Apply juxtapose with that zip as input and L as output
                        i.e. "a" concatenated I times to itself makes the first string of L
                        and "b" concatenated I times to itself makes the second string of L

— Fatalize
स्रोत

8

Tryitonline.net पर आने के लिए बधाई!

— लीकी नून

10

05AB1E , 9 बाइट्स

कोड:

.M{J¹ÔQ0r

स्पष्टीकरण:

.M         # Get the most frequent element from the input. If the count is equal, this
           results into ['a', 'b'] or ['b', 'a'].
  {        # Sort this list, which should result into ['a', 'b'].
   J       # Join this list.
    Ô      # Connected uniquified. E.g. "aaabbb" -> "ab" and "aabbaa" -> "aba".
     Q     # Check if both strings are equal.
      0r   # (Print 0 if the input is empty).

यदि इनपुट खाली न हो तो अंतिम दो बाइट्स को छोड़ दिया जा सकता है।

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

खाली इनपुट से क्या होता है?

— AdmBorkBork

2

के लिए देखो गैर शून्य पोस्ट में; यह वहां है :)

— लिन

@Lynn केवल एक वैध भाषा के लिए शून्य नहीं कहना कल्पना नहीं करता है? इनपुट के बारे में नहीं।

— एमिग्ना

सच। वहां गलत सोचा। लेकिन आप अभी भी आपके लिए कर सकते हैं .M{J¹ÔQ0r।

— एमिगा जूल 20'16

@Emigna धन्यवाद, मैंने पोस्ट को संपादित किया है।

— अदनान

9

जेली , 6 बाइट्स

Ṣ=Ṛ¬Pȧ

स्ट्रिंग को स्वयं प्रिंट करता है यदि यह L से संबंधित है या रिक्त है, और 0 अन्यथा।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

Ṣ=Ṛ¬Pȧ  Main link. Argument: s (string)

Ṣ       Yield s, sorted.
  Ṛ     Yield s, reversed.
 =      Compare each character of sorted s with each character of reversed s.
   ¬    Take the logical NOT of each resulting Boolean.
    P   Take the product of the resulting Booleans.
        This will yield 1 if s ∊ L or s == "", and 0 otherwise.
     ȧ  Take the logical AND with s.
       This will replace 1 with s. Since an empty string is falsy in Jelly,
       the result is still correct if s == "".

वैकल्पिक संस्करण, 4 बाइट्स (गैर-प्रतिस्पर्धात्मक)

ṢnṚȦ

प्रिंट 1 या 0 । इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

ṢnṚȦ  Main link. Argument: s (string)

Ṣ     Yield s, sorted.
  Ṛ   Yield s, reversed.
 n    Compare each character of the results, returning 1 iff they're not equal.
   Ȧ  All (Octave-style truthy); return 1 if the list is non-empty and all numbers
      are non-zero, 0 in all other cases.

— डेनिस
स्रोत

9

जे, 17 बाइट्स

#<.(-:'ab'#~-:@#)

यह खाली स्ट्रिंग के लिए फालसे देने के लिए सही तरीके से काम करता है। त्रुटि गलत है।

पुराने संस्करणों:

-:'ab'#~-:@#
2&#-:'ab'#~#   NB. thanks to miles

प्रमाण और स्पष्टीकरण

मुख्य क्रिया इन तीन क्रियाओं से युक्त एक कांटा है:

# <. (-:'ab'#~-:@#)

इसका मतलब है, "कम ( <.) लंबाई ( #) और सही टाइन का परिणाम ( (-:'ab'#~-:@#))"।

दायीं ओर की टाइन एक 4-ट्रेन है , जिसमें शामिल हैं:

(-:) ('ab') (#~) (-:@#)

चलो kहमारे इनपुट प्रतिनिधित्व करते हैं। फिर, यह इसके बराबर है:

k -: ('ab' #~ -:@#) k

-:मैच ऑपरेटर है, इसलिए -:मोनडिक कांटा के तहत आक्रमण के लिए अग्रणी परीक्षण 'ab' #~ -:@#।

चूँकि कांटा का बायाँ भाग एक क्रिया है, यह एक स्थिर कार्य बन जाता है। तो, कांटा इसके बराबर है:

'ab' #~ (-:@# k)

कांटा आधा की दाईं ओर ( -:) लंबाई ( #) का है k। निरीक्षण करें #:

   1 # 'ab'
'ab'
   2 # 'ab'
'aabb'
   3 # 'ab'
'aaabbb'
   'ab' #~ 3
'aaabbb'

अब, यह kकेवल मान्य इनपुट्स पर है, इसलिए हम यहां किए गए हैं। #विषम-लंबाई के तार के लिए त्रुटियां, जो कभी भी भाषा को संतुष्ट नहीं करती हैं, इसलिए वहां हम भी होते हैं।

लंबाई के कम के साथ संयुक्त और यह, खाली स्ट्रिंग, जो हमारी भाषा का हिस्सा नहीं है, इसकी लंबाई पैदावार देती है 0, और हम यह सब करते हैं।

— कोनोर ओ ब्रायन
स्रोत

मैंने इसे संशोधित किया 2&#-:'ab'#~#जिसमें आपको 012 बाइट्स का उपयोग करते समय त्रुटि और सिर्फ आउटपुट से बचने देना चाहिए ।

— मील

@ मीलों का मोह! मैंने इसके बारे में कभी ऐसा नहीं सोचा था।

— कॉनर ओ'ब्रायन

क्या यह रिक्त स्ट्रिंग को संभालता है?

— जर्गबुल

@Zgarb ने इसे ठीक किया!

— कॉनर ओ'ब्रायन

9

बाइसन / YACC 60 (या 29) बाइट्स

(खैर, एक YACC कार्यक्रम के लिए संकलन कुछ चरणों का एक हिस्सा है, इसलिए इसके लिए कुछ को शामिल करना चाह सकते हैं। विवरण के लिए नीचे देखें।)

%%
l:c'\n';
c:'a''b'|'a'c'b';
%%
yylex(){return getchar();}

यदि आप औपचारिक व्याकरण के संदर्भ में इसकी व्याख्या करना जानते हैं तो यह कार्य काफी स्पष्ट होना चाहिए। पार्सर abया तो स्वीकार करता है या aकिसी भी स्वीकार्य अनुक्रम द्वारा पीछा किया जाता है b।

यह कार्यान्वयन एक संकलक पर निर्भर करता है जो कुछ वर्णों को खोने के लिए K & R शब्दार्थ को स्वीकार करता है।

यह परिभाषित करने yylexऔर कॉल करने की आवश्यकता के साथ की तुलना में अधिक स्पष्ट है getchar।

संकलन

$ yacc equal.yacc
$ gcc -m64 --std=c89 y.tab.c -o equal -L/usr/local/opt/bison/lib/ -ly

(जीसीसी के अधिकांश विकल्प मेरे सिस्टम के लिए विशिष्ट हैं और बाइट की गिनती के खिलाफ नहीं होनी चाहिए; आप गिनना चाह सकते हैं -std=c89जो 8 से सूचीबद्ध मूल्य में जोड़ता है)।

साथ दौड़ो

$ echo "aabb" | ./equal

या उसके बराबर।

सत्य मान OS पर वापस आ जाता है और त्रुटियां syntax errorकमांड लाइन को भी रिपोर्ट करती हैं । यदि मैं पार्सिंग फ़ंक्शन को परिभाषित करने वाले कोड के केवल भाग की गणना कर सकता हूं (जो कि दूसरे %%और सभी की उपेक्षा है) तो मुझे 29 बाइट्स की एक गिनती मिलती है।

— dmckee
स्रोत

7

Perl 5.10, 35 17 बाइट (साथ -n झंडा)

say/^(a(?1)?b)$/

यह सुनिश्चित करता है कि स्ट्रिंग as से शुरू होती है और फिर bs पर फिर से आती है । यह तभी मैच करता है जब दोनों की लंबाई समान हो।

मार्टिन एंडर को बाइट काउंट को रोकने और मुझे रेगीज़ में पुनरावृत्ति के बारे में थोड़ा सिखाने के लिए धन्यवाद : डी

यदि यह मेल खाता है, तो यह पूरी स्ट्रिंग लौटाता है और यदि नहीं तो कुछ भी नहीं।

यहाँ यह कोशिश करो!

— पॉल पिकार्ड
स्रोत

निकटतम मैं गैर-खाली परीक्षण मामले सहित प्रबंधन कर सकता है 18 बाइट्स हैं: $_&&=y/a//==y/b//(आवश्यकता है -p), खाली के बिना आप &&16 के लिए छोड़ सकते हैं ! इतना करीब ...

— डोम हेस्टिंग्स

1

तो मैं एक और 17 बाइट्स echo -n 'aaabbb'|perl -pe '$_+=y/a//==y/b//'कर सकता हूं : लेकिन मैं एक और बाइट शिफ्ट नहीं कर सकता ... इस पर हार माननी पड़ सकती है!

— डोम हेस्टिंग्स

7

जावास्क्रिप्ट, 54 55 44

s=>s&&s.match(`^a{${l=s.length/2}}b{${l}}$`)

स्ट्रिंग की लंबाई के आधार पर एक साधारण रेगेक्स बनाता है और इसका परीक्षण करता है। लंबाई 4 स्ट्रिंग ( aabb) के लिए रेगेक्स जैसा दिखता है:^a{2}b{2}$

एक सत्य या गलत मूल्य देता है।

11 बाइट्स ने नील को धन्यवाद दिया।

f=s=>s&&s.match(`^a{${l=s.length/2}}b{${l}}$`)
// true
console.log(f('ab'), !!f('ab'))
console.log(f('aabb'), !!f('aabb'))
console.log(f('aaaaabbbbb'), !!f('aaaaabbbbb'))
// false
console.log(f('a'), !!f('a'))
console.log(f('b'), !!f('b'))
console.log(f('ba'), !!f('ba'))
console.log(f('aaab'), !!f('aaab'))
console.log(f('ababab'), !!f('ababab'))
console.log(f('c'), !!f('c'))
console.log(f('abc'), !!f('abc'))
console.log(f(''), !!f(''))

स्निपेट का विस्तार करें

— Scimonster
स्रोत

f=छोड़ा जा सकता है।

— लीक

क्या फंक्शन एक्सप्रेशन एक मान्य सबमिशन है, या यह वास्तव में होना चाहिए, अहम, कार्यात्मक?

— स्किमोनस्टर

एक फ़ंक्शन एक मान्य सबमिशन है।

— लीक नन

@ टिम्मीड यह सच लौटा करता था, लेकिन अब यह गलत है।

— शिमोनस्टर

1

s=>s.match(`^a{${s.length/2}}b+$`)?

— l4m2

5

सी, 57 53 बाइट्स

t;x(char*s){t+=*s%2*2;return--t?*s&&x(s+1):*s*!1[s];}

पुराना 57 बाइट्स लंबा घोल:

t;x(char*s){*s&1&&(t+=2);return--t?*s&&x(s+1):*s&&!1[s];}

Gcc v। 4.8.2 @Ubuntu के साथ संकलित

सुझाव के लिए धन्यवाद ugoren!

Ideone पर यह कोशिश करो!

— Jasmes
स्रोत

चूंकि मैं यहां नया हूं और अन्य उत्तरों पर अभी तक टिप्पणी नहीं कर सकता, इसलिए मैं सिर्फ यह बताना चाहता हूं कि @ जोश से 62b समाधान "आआबाब" जैसे तार पर गलत सकारात्मक देता है।

— जसम

बदले (t+=2)के लिए t++++-1 बाइट के लिए।

— उल्लू के साथ

@owacoder t++++एक मान्य C कोड नहीं है।

— Jasmes

t+=*s%2*2:*s*!1[s]

— जूल

बहुत चालाक जवाब! यह दुर्भाग्य से इनपुट "बा" पर विफल रहता है: ideone.com/yxixG2

— जोश

4

रेटिना , 22 बाइट्स

उसी भाषा में एक और छोटा जवाब आया ...

^(a)+(?<-1>b)+(?(1)c)$

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

यह रेगेक्स में संतुलन समूहों का एक शोकेस है, जिसे मार्टिन एंडर द्वारा पूरी तरह से समझाया गया है ।

जैसा कि मेरी व्याख्या इसके आधे हिस्से के करीब नहीं आएगी, मैं सिर्फ इसे लिंक करूंगा और समझाने का प्रयास नहीं करूंगा, क्योंकि यह उनके स्पष्टीकरण की महिमा के लिए हानिकारक होगा।

— लीक नन
स्रोत

4

बेफुज -93, 67 बाइट्स

0v@.<  0<@.!-$<  >0\v
+>~:0`!#^_:"a" -#^_$ 1
~+1_^#!-"b" _ ^#`0: <

यहाँ कोशिश करो! यह समझाता है कि यह बाद में कैसे काम करता है। यह सिर्फ किक के लिए सिर्फ थोड़ा और अधिक, गोल्फ के लिए प्रयास कर सकता है।

3

MATL , 9 बाइट्स

vHI$e!d1=

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

यदि यह गैर-रिक्त है और इसका सभी प्रविष्टियाँ गैर-शून्य हैं, तो आउटपुट सरणी सत्य है। अन्यथा यह मिथ्या है। यहाँ कुछ उदाहरण हैं ।

v     % concatenate the stack. Since it's empty, pushes the empty array, []
H     % push 2
I$    % specify three inputs for next function
e     % reshape(input, [], 2): this takes the input implicitly and reshapes it in 2
      % columns in column major order. If the input has odd length a zero is padded at
      % the end. For input 'aaabbb' this gives the 2D char array ['ab;'ab';'ab']
!     % transpose. This gives ['aaa;'bbb']
d     % difference along each column
1=    % test if all elements are 1. If so, that means the first tow contains 'a' and
      % the second 'b'. Implicitly display

— लुइस मेंडो
स्रोत

2

यह सच्चाई की कुछ सुविधाजनक परिभाषा है। (मैं गैर-शून्य आवश्यकता के बारे में जानता था, लेकिन गैर-खाली एक के बारे में नहीं।)

— डेनिस

3

x86 मशीन कोड, 29 27 बाइट्स

Hexdump:

33 c0 40 41 80 79 ff 61 74 f8 48 41 80 79 fe 62
74 f8 0a 41 fe f7 d8 1b c0 40 c3

विधानसभा कोड:

    xor eax, eax;
loop1:
    inc eax;
    inc ecx;
    cmp byte ptr [ecx-1], 'a';
    je loop1;

loop2:
    dec eax;
    inc ecx;
    cmp byte ptr [ecx-2], 'b';
    je loop2;

    or al, [ecx-2];
    neg eax;
    sbb eax, eax;
    inc eax;
done:
    ret;

aशुरुआत में बाइट्स पर Iterates , फिर निम्नलिखित 'b' बाइट्स पर। पहला लूप एक काउंटर बढ़ाता है, और दूसरा लूप इसे घटाता है। बाद में, निम्न स्थितियों के बीच एक बिटवाइज़ या करता है:

यदि काउंटर अंत में 0 नहीं है, तो स्ट्रिंग मेल नहीं खाती
यदि बाइट जो bs के अनुक्रम का अनुसरण करता है 0 नहीं है, तो स्ट्रिंग भी मेल नहीं खाती है

फिर, इसमें सत्य मूल्य को " eaxउल्टा " करना है - इसे 0 पर सेट करें यदि यह 0 नहीं था, और इसके विपरीत। यह पता चला है कि ऐसा करने वाला सबसे छोटा कोड निम्नलिखित 5-बाइट कोड है, जिसे मैंने अपने C ++ कंपाइलर के आउटपुट से चुरा लिया है result = (result == 0):

    neg eax;      // negate eax; set C flag to 1 if it was nonzero
    sbb eax, eax; // subtract eax and the C flag from eax
    inc eax;      // increase eax

— anatolyg
स्रोत

1

मुझे लगता है कि आप अपनी उपेक्षा को सुधार सकते हैं। कोशिश करें: neg eaxकैरी फ़्लैग को पहले की तरह सेट करने के लिए, कैरी फ़्लैग cmcको पलटने के लिए और salcAL को FFh या 0 पर सेट करने के लिए सेट करें कि कैरी फ़्लैग सेट है या नहीं। 2 बाइट्स बचाता है, हालांकि 32-बिट के बजाय 8-बिट परिणाम के साथ समाप्त होता है।

— जूल्स

स्ट्रिंग ऑप्स का उपयोग करने वाली एक ही चीज, इनपुट स्ट्रिंग की ओर इशारा करते हुए ईएसआई के साथ, और AL में परिणाम लौटाता है (SETcc का उपयोग करता है, इसके लिए 386+ की आवश्यकता होती है):

xor eax,eax | xor ecx,ecx | l1: inc ecx | lodsb | cmp al, 'a' | jz l1 | dec esi | l2: lodsb | cmp al,'b' | loopz l2 | or eax,ecx | setz al | ret

— ninjalj

@njjalj आपको उत्तर देना चाहिए कि यह पर्याप्त रूप से मेरा अलग है, और मुझे संदेह है कि यह काफी छोटा है!

— अनातोलीग

3

रूबी, 24 बाइट्स

eval(gets.tr'ab','[]')*1

(यह रूबी रूप में सिर्फ xnor का शानदार विचार है। मेरा दूसरा जवाब एक समाधान है जो मैं वास्तव में खुद के साथ आया था)

कार्यक्रम इनपुट लेता बदल देती है, aऔर bकरने के लिए [और ]क्रमश: और यह मूल्यांकन करता है।

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

— daniero
स्रोत

3

सेड, 38 + 2 = 40 बाइट्स

s/.*/c&d/;:x;s/ca(.*)bd/c\1d/;tx;/cd/p

^{एक गैर खाली स्ट्रिंग आउटपुट सत्य है}

परिमित राज्य ऑटोमेटा ऐसा नहीं कर सकता, आप कहते हैं? छोरों के साथ परिमित राज्य ऑटोमेटा के बारे में क्या । : पी

rऔर nझंडे लेकर चलें।

व्याख्या

s/.*/c&d/        #Wrap the input in 'c' and 'd' (used as markers)
:x               #Define a label named 'x'
s/ca(.*)bd/c\1d/ #Deletes 'a's preceded by 'c's and equivalently for 'b's and 'd's. This shifts the markers to the center
tx               #If the previous substitution was made, jump to label x
/cd/p            #If the markers are next to one another, print the string

— someonewithpc
स्रोत

अच्छा तरीका। टूटने के लिए धन्यवाद।

— joeytwiddle

3

जावास्क्रिप्ट, ४४ ४२

^{पार किया 44 अभी भी नियमित है 44 ;;}

f=s=>(z=s.match`^a(.+)b$`)?f(z[1]):s=="ab"

रिकर्सिवली बाहरी बंद अलग करना द्वारा काम करता है aऔर bऔर रिकर्सिवली चयनित आंतरिक मूल्य का उपयोग कर, लेकिन .+। जब ^a.+b$बाईं ओर कोई मैच नहीं होता है , तो अंतिम परिणाम यह है कि क्या शेष स्ट्रिंग सटीक मान है ab।

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

console.log(["ab","aabb","aaabbb","aaaabbbb","aaaaabbbbb","aaaaaabbbbbb"].every(f) == true)
console.log(["","a","b","aa","ba","bb","aaa","aab","aba","abb","baa","bab","bba","bbb","aaaa","aaab","aaba","abaa","abab","abba","abbb","baaa","baab","baba","babb","bbaa","bbab","bbba","bbbb"].some(f) == false)

— apsillers
स्रोत

3

ANTLR, 31 बाइट्स

grammar A;r:'ab'|'a'r'b'|r'\n';

@ Dmckee के YACC उत्तर के समान अवधारणा का उपयोग करता है , बस थोड़ा अधिक गॉल्फर्ड।

परीक्षण करने के लिए, ANTLR के स्टार्टिंग ट्यूटोरियल में चरणों का पालन करें । फिर, उपरोक्त कोड को एक फ़ाइल में रखा गया है जिसका नाम है A.g4और इन कमांड को रन करें:

$ antlr A.g4
$ javac A*.java

इसके बाद STDIN पर इनपुट देकर टेस्ट करें grun A r, जैसे:

$ echo "aaabbb" | grun A r

यदि इनपुट वैध है, तो कुछ भी आउटपुट नहीं होगा; अगर यह अवैध है, grunएक त्रुटि दे देंगे (या तो token recognition error, extraneous input, mismatched input, या no viable alternative)।

उदाहरण का उपयोग:

$ echo "aabb" | grun A r
$ echo "abbb" | grun A r
line 1:2 mismatched input 'b' expecting {<EOF>, '
'}

— तांबा
स्रोत

चतुर चाल एक ही नियम में वैकल्पिक के रूप में नई रेखा जोड़ रही है। मुझे लगता है कि मैं कुछ तरीका याक में भी बचा सकता हूं। grammerकीवर्ड antlr साथ गोल्फ के लिए एक बदमाश है, हालांकि है। किंडा को फोरट्रान का उपयोग करना पसंद है ।

— dmckee

3

सी, 69 बाइट्स

69 बाइट्स:

#define f(s)strlen(s)==2*strcspn(s,"b")&strrchr(s,97)+1==strchr(s,98)

अपरिचित लोगों के लिए:

strlen स्ट्रिंग की लंबाई निर्धारित करता है
strcspn स्ट्रिंग में पहला इंडेक्स देता है जहां दूसरा स्ट्रिंग पाया जाता है
strchr एक चरित्र की पहली घटना के लिए एक संकेतक लौटाता है
strrchr एक चरित्र की अंतिम घटना के लिए एक संकेतक लौटाता है

टाइटस के लिए एक बड़ा धन्यवाद!

— हंसी मजाक करना
स्रोत

1

>97इसके बजाय एक बाइट बचाओ==98

— टाइटस

2

61 बाइट्स समाधान "आआबाब" जैसे तारों पर गलत सकारात्मक देता है। देखें ideone.com/nmT8rm

— जैम्स

आह, आप सही हैं जैस्मीन, धन्यवाद। मुझे इस पर थोड़ा पुनर्विचार करना होगा।

— जोश

69 बाइट समाधान पर वापस लौटना, मुझे यकीन नहीं है कि अगर मैं इस दृष्टिकोण का उपयोग करके किसी भी छोटे को प्राप्त कर सकता हूं।

— जोश

3

आर, 64 61 55 बाइट्स, 73 67 बाइट्स (मजबूत) या 46 बाइट्स (यदि खाली तारों की अनुमति है)

फिर, xnor का जवाब फिर से काम किया। यदि यह नियमों द्वारा निहित है कि इनपुट में as और bs की एक स्ट्रिंग शामिल होगी , तो यह काम करना चाहिए: NULL लौटाता है यदि अभिव्यक्ति वैध है, फेंकता है और त्रुटि या अन्यथा कुछ भी नहीं है।
```
if((y<-scan(,''))>'')eval(parse(t=chartr('ab','{}',y)))
```
यदि इनपुट मजबूत नहीं है और इसमें कुछ कचरा हो सकता है, उदाहरण के लिए aa3bb, तो निम्नलिखित संस्करण पर विचार किया जाना चाहिए ( TRUEसही परीक्षण मामलों के लिए वापस लौटना चाहिए , NULL नहीं):
```
if(length(y<-scan(,'')))is.null(eval(parse(t=chartr("ab","{}",y))))
```
अंत में, यदि खाली तारों की अनुमति दी जाती है, तो हम गैर-रिक्त इनपुट के लिए स्थिति को अनदेखा कर सकते हैं:
```
eval(parse(text=chartr("ab","{}",scan(,''))))
```
फिर, NULL अगर सफलता, अन्यथा कुछ भी।

— आंद्रे कोस्टीर्का
स्रोत

मैं आर को नहीं जानता, खाली इनपुट के लिए आपका परिणाम क्या है? (मिथ्या होना चाहिए)

— टाइटस

क्या वास्तव में खाली इनपुट के लिए परीक्षण करने का कोई तरीका नहीं है?

— टाइटस

संस्करण 1: बस कुछ भी नहीं (केवल सही रिटर्न देता है NULL), संस्करण 2: बस कुछ भी नहीं (केवल सही इनपुट रिटर्न देता है TRUE), संस्करण 3 (खाली तारों को ठीक मानते हुए, राज्य के रूप में) NULL:। R एक सांख्यिकीय ऑब्जेक्ट-ओरिएंटेड भाषा है जो बिना किसी चेतावनी के सब कुछ ठीक टाइपकास्ट करती है।

— आंद्रे

इस (उत्तर 1) को 55 बाइट्स में और बेहतर बनाया जा सकता है:if((y<-scan(,''))>'')eval(parse(t=chartr('ab','{}',y)))

— Giuseppe

3

जाप , 11 बाइट्स

©¬n eÈ¦Ug~Y

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

देता है या तो trueया false, सिवाय इसके कि ""देता है ""जो जे एस में falsy है।

अनपैक्ड और यह कैसे काम करता है

U&&Uq n eXYZ{X!=Ug~Y

U&&     The input string is not empty, and...
Uq n    Convert to array of chars and sort
eXYZ{   Does every element satisfy...?
X!=       The sorted char does not equal...
Ug~Y      the char at the same position on the original string reversed

डेनिस 'MATL समाधान से अपनाया ।

— bubbler
स्रोत

2

सी (एएनआई), 65 75 बाइट्स

golfed:

l(b,i,j,k)char*b;{for(i=j=0;(k=b[i++])>0&k<=b[i];)j+=2*(k>97)-1;return !j;}

स्पष्टीकरण:

प्रत्येक b पर मान j और वेतन वृद्धि j सेट करता है और j पर कुछ और घटता है। जाँच की जाती है कि क्या पहले वाला अक्षर अगले अक्षर से कम या बराबर है, इसलिए अबाब को काम करने से रोकें

संपादित करता

अबाब मामलों के लिए चेक जोड़े गए।

— dj0wns
स्रोत

इस तरह baया तार पर झूठी सकारात्मक नहीं देंगे abab?

— जर्बेर जूल

आह हां, मैंने पोस्ट को गलत बताया है क्योंकि मैं उसके लिए अवरुद्ध होने के बाद से तस्वीर नहीं देख सकता था। इसे ठीक करना!

— dj0wns

2

बैच, 133 बाइट्स

@if ""=="%1" exit/b1        Fail if the input is empty
@set a=%1                   Grab the input into a variable for processing
@set b=%a:ab=%              Remove all `ab` substrings
@if "%a%"=="%b%" exit/b1    Fail if we didn't remove anything
@if not %a%==a%b%b exit/b1  Fail if we removed more than one `ab`
@if ""=="%b%" exit/b0       Success if there's nothing left to check
@%0 %b%                     Rinse and repeat

ERRORLEVELसफलता पर 0 की वापसी , 1 असफलता पर। बैच खाली तारों पर प्रतिस्थापन प्रतिस्थापन करना पसंद नहीं करता है, इसलिए हमें उस सामने की जांच करनी होगी; यदि कोई खाली पैरामीटर कानूनी था, तो पंक्ति 6 आवश्यक नहीं होगी।

— नील
स्रोत

2

PowerShell v2 +, 61 52 बाइट्स

param($n)$x=$n.length/2;$n-and$n-match"^a{$x}b{$x}$"

$nएक स्ट्रिंग के रूप में इनपुट लेता है , $xजैसा बनाता है half the length। कंस्ट्रक्शन एक -andके बीच बूलियन तुलना $nऔर एक -matchकी एक समान संख्या के regex के खिलाफ regex ऑपरेटर aकी और bके। आउटपुट बूलियन $TRUEया $FALSE। $n-andके लिए खाते है ""= $FALSE।

वैकल्पिक, 35 बाइट्स

$args-match'^(a)+(?<-1>b)+(?(1)c)$'

यह Leaky के उत्तर से रेगेक्स का उपयोग करता है , जो कि .NET बैलेंसिंग समूहों पर आधारित है, जो कि PowerShell -matchऑपरेटर में सिर्फ समझाया गया है । सत्य के लिए स्ट्रिंग लौटाता है, या फालसे के लिए खाली स्ट्रिंग देता है।

— AdmBorkBork
स्रोत

वैकल्पिक संस्करण में, आपको इसके -matchविरुद्ध मूल्यांकन करना चाहिए $args[0], अन्यथा -matchएक फिल्टर के रूप में काम करेगा

— मैथियास आर। जेसेन

@ MathiasR.Jessen उत्पादन कोड में, हाँ, लेकिन हम [0]यहाँ गोल्फ कर सकते हैं क्योंकि हमें केवल एक इनपुट दिया गया है और हमें आउटपुट के रूप में केवल एक सत्य / गलत मूल्य की आवश्यकता है। चूंकि एक रिक्त स्ट्रिंग गलत है और एक गैर-रिक्त स्ट्रिंग सत्य है, हम सरणी के खिलाफ फ़िल्टर कर सकते हैं और या तो इनपुट स्ट्रिंग को वापस पा सकते हैं या कुछ भी वापस नहीं कर सकते हैं, जो चुनौती की आवश्यकताओं को पूरा करता है।

— AdmBorkBork

2

पायथ - 13 बाइट्स

&zqzS*/lz2"ab

व्याख्या की:

  qz          #is input equal to
          "ab #the string "ab"
     *        #multiplied by
      /lz2    #length of input / 2
    S         #and sorted?
&z            #(implicitly) print if the above is true and z is not empty

— Cowabunghole
स्रोत

आप इनपुट के रूप में एक स्ट्रिंग का उपयोग कर सकते हैं और फिर इसे बना सकते हैं&qS*/lQ2"ab

— लीक नून

@LeakyNun टिप के लिए धन्यवाद! क्या आप बता सकते हैं कि कैसे / क्यों काम करता है? यह मेरी पहली बार पाइथ

— काउबुनघोल जूल

उदाहरण के लिए, +4विस्तार +4Q(तर्कों के निहितार्थ)

— लीक नून

2

हास्केल, 39 बाइट्स

p x=elem x$scanl(\s _->'a':s++"b")"ab"x

प्रयोग उदाहरण: p "aabb"-> True।

scanl(\s _->'a':s++"b")"ab"x["ab", "aabb", "aaabbb", ...]कुल (length x)तत्वों के साथ सभी की सूची बनाएँ । elemजाँच करता है कि xक्या इस सूची में है।

— nimi
स्रोत

2

पायथन, 43 40 बाइट्स

lambda s:''<s==len(s)/2*"a"+len(s)/2*"b"

connsidered को स्पष्ट समाधान धन्यवाद लीकी नून

अन्य विचार, 45 बाइट्स:

lambda s:s and list(s)==sorted(len(s)/2*"ab")

-4 बाइट्स लेन / 2 का उपयोग करके (जब आधा आता है तो मुझे एक त्रुटि मिलती है)

अब खाली स्ट्रिंग के लिए गलत देता है

-3 बाइट्स xnor के लिए धन्यवाद

— KarlKastor
स्रोत

हां, लंबोदर का नाम नहीं है।

— लीक से हटकर नून

lambda s:list(s)==sorted("ab"*len(s)//2)(पाइथन 3)

— लीक नून

lambda s:s=="a"*len(s)//2+"b"*len(s)//2(पाइथन 3)

— लीक नून

हाँ, मुझे एहसास हुआ कि इसे पोस्ट करते समय। योग्य, स्पष्ट समाधान पायथन 2 में छोटा है:

— कार्लक्स्टोर

1

आप खाली मामले को खारिज करने के ''<बजाय कर सकते हैं s and।

— xnor

“A” s और “b” s की गिनती बराबर होनी चाहिए। क्या आपको यह कंप्यूटर मिला?

चुनौती

सत्य परीक्षण के मामले

झूठे परीक्षण के मामले

MATL , 5 4 बाइट्स

यह काम किस प्रकार करता है

पायथन 3, 32 बाइट्स

रेटिना , 12 बाइट्स

व्याख्या

हास्केल, 31 बाइट्स

पीस , 12 बाइट्स

व्याख्या

8-बाइट नॉनकंपेटिंग संस्करण

ब्रेकीलॉग , 23 19 बाइट्स

व्याख्या

05AB1E , 9 बाइट्स

जेली , 6 बाइट्स

यह काम किस प्रकार करता है

वैकल्पिक संस्करण, 4 बाइट्स (गैर-प्रतिस्पर्धात्मक)

यह काम किस प्रकार करता है

जे, 17 बाइट्स

प्रमाण और स्पष्टीकरण

बाइसन / YACC 60 (या 29) बाइट्स

Perl 5.10, 35 17 बाइट (साथ -n झंडा)

जावास्क्रिप्ट, 54 55 44

सी, 57 53 बाइट्स

रेटिना , 22 बाइट्स

बेफुज -93, 67 बाइट्स

MATL , 9 बाइट्स

x86 मशीन कोड, 29 27 बाइट्स

रूबी, 24 बाइट्स

सेड, 38 + 2 = 40 बाइट्स

व्याख्या

जावास्क्रिप्ट, ४४ ४२

ANTLR, 31 बाइट्स

सी, 69 बाइट्स

आर, 64 61 55 बाइट्स, 73 67 बाइट्स (मजबूत) या 46 बाइट्स (यदि खाली तारों की अनुमति है)

जाप , 11 बाइट्स

अनपैक्ड और यह कैसे काम करता है

सी (एएनआई), 65 75 बाइट्स

golfed:

स्पष्टीकरण:

संपादित करता

बैच, 133 बाइट्स

PowerShell v2 +, 61 52 बाइट्स

वैकल्पिक, 35 बाइट्स

पायथ - 13 बाइट्स

हास्केल, 39 बाइट्स

पायथन, 43 40 बाइट्स