परफेक्ट पेयरिंग्स का पता लगाएं

Question

चलो एक फ़ंक्शन जो एक स्ट्रिंग लेता है और आसन्न समान वर्णों के सभी जोड़े निकालता है। उदाहरण के लिए$f$

$f(a\color{red}{bb}ba\color{red}{cc}) = aba$

ध्यान दें कि जब दो जोड़े ओवरलैप होते हैं तो हम उनमें से केवल एक को हटाते हैं।

हम एक स्ट्रिंग को पूरी तरह से युग्मित कहेंगे यदि दोहराया गया आवेदन अंततः खाली स्ट्रिंग देता है। उदाहरण के लिए ऊपर का तार पूरी तरह से जोड़ा नहीं गया है क्योंकि अगर हम फिर से तो भी हमें मिलता है । हालांकि जैसा एक तार पूरी तरह से जोड़ा जाता है क्योंकि अगर हम तीन बार तो हमें खाली स्ट्रिंग मिलती हैच एक ख एक ई एक ख ख ग ग एक घ घ ई $abbbacc$$f$$aba$$eabbccadde$$f$

$f(ea\color{red}{bbcc}a\color{red}{dd}e) = eaae$

$f(e\color{red}{aa}e) = ee$

$f(\color{red}{ee}) =$

---

आपका कार्य पूरी तरह से युग्मित कंप्यूटर कोड लिखना है जो एक स्ट्रिंग (प्रिंट करने योग्य एएससीआईआई) लेता है और यह तय करता है कि क्या यह पूरी तरह से युग्मित है। आपके स्रोत का बाइटस्ट्रिंग स्वयं एक पूरी तरह से युग्मित स्ट्रिंग होना चाहिए , हालांकि आपके कोड को मुद्रण योग्य ASCII तक सीमित नहीं होना चाहिए।

आप दो अलग-अलग मानों का उत्पादन कर सकते हैं: एक उस मामले के लिए जहां इनपुट पूरी तरह से जोड़ा जाता है, और उन मामलों के लिए एक और जहां यह नहीं है।

यह एक कोड-गोल्फ प्रश्न है, इसलिए उत्तर उनके बाइट्स के आकार से कम बाइट्स बेहतर होने के कारण बनाए जाएंगे।

---

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

$abbbacc \rightarrow \mathrm{False}\\ abcba \rightarrow \mathrm{False}\\ abab \rightarrow \mathrm{False}\\ abbbaabacc \rightarrow \mathrm{True}\\ eabbccadde \rightarrow \mathrm{True}\\ bbbb \rightarrow \mathrm{True}$

Comments

हालांकि अब इसे बदलने में बहुत देर हो सकती है, मुझे लगता है कि यदि आप टिप्पणी या समान "मृत" कोड की अनुमति देते हैं तो चुनौती का "मोड़" भाग लगभग व्यर्थ हो जाता है।

— जियोबिट्स

@ जीबिट्स मैं असहमत हूं। एक के लिए मुझे लगता है कि मृत कोड को अस्वीकार करना केवल अस्पष्ट परिभाषाओं का एक हिस्सा है और कभी भी मजेदार नहीं होता है। दो के लिए मुझे लगता है कि टिप्पणियों की अनुमति प्रविष्टि के बार को कम करती है। तीन के लिए मेरा मानना ​​है कि टिप्पणी-कम कोड अनिवार्य रूप से टिप्पणी-पूर्ण कोड की तुलना में बेहतर स्कोरिंग होगा। हो सकता है कि मोड़ मज़ेदार न हो, लेकिन यह निश्चित रूप से कम मज़ेदार होगा, अगर मैंने किसी विशेष तरीके से उत्तर देने के लिए अप्रतिबंधित प्रतिबंधों को जोड़ा।

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

Unary आपके स्रोत प्रतिबंध नियम, mwahahahaha (यानी ... जब तक कि उत्तर में बाइट्स की एक संख्या है) के बारे में कोई लानत नहीं देता है।

— अरनौलड़

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

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

@dylnan खाली स्ट्रिंग हो सकता है, लूपिंग हमेशा के लिए मान्य आउटपुट नहीं है।

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

Answer 1

हास्केल, 146 124 बाइट्स

((""##))
a===bb=bb==a
((aa:bb))##((cc:dd))|aa===cc=bb##dd|1==1=((cc:aa:bb))##dd
a##""=""===a
""##cc=((cc!!00:cc!!00:""))##cc

कोई टिप्पणी नहीं। Trueया तो लौटता है या False।

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

संपादित करें: -22 बाइट्स @Cat जादूगर के लिए धन्यवाद

Comments

यह हैसेल की तरह कम से कम हैस्केल मैंने कभी देखा है

— घन

Answer 2

पायथन 2 , 94 बाइट्स

ss=''

for cc in input():ss=[cc+ss,ss[1:]][cc==ss[:1]]

print''==ss##tnirp[,+[=:)(tupni nirof=

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

पूरे अद्यतन कदम को ss=[cc+ss,ss[1:]][cc==ss[:1]]रद्द कर देता है =[+,[।

Answer 3

05AB1E , 26 24 22 20 18 बाइट्स

-2 बाइट्स ओव्स के लिए धन्यवाद । आउटपुट 0 यदि स्ट्रिंग पूरी तरह से युग्मित है, तो 1 अन्यथा।

ΔγʒgÉ}JJ}ĀqqĀÉgʒγΔ

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

ĀÉgĀÉ} JJ} JqqʒγΔg Full - पूर्ण कार्यक्रम।
Δ} - जब तक परिणाम नहीं बदलता है:
 γʒ} - स्ट्रिंग को समान वर्णों के टुकड़ों में विभाजित करें और इसके अनुसार फ़िल्टर करें:
   g - क्या लंबाई विषम है?
      जेजे - और फ़िल्टर करने के बाद, भागों को वापस एक साथ मिलाएं, लेकिन ऐसा करें
                     पिछले संस्करणों की तरह, दो बाइट्स को बचाने के लिए दो बार।
         The - जांचें कि क्या परिणाम खाली है
          क्ष - समाप्त (छोड़ें) निष्पादन। बाकी कोड को नजरअंदाज कर दिया जाता है।
           qg to - स्रोत लेआउट के साथ मदद करने के लिए गैर-मिलान किए गए भाग को मिरर करें।

---

पिछला संस्करण

यह पूरी तरह से अपरिभाषित व्यवहार पर निर्भर करता है (इसलिए इसमें कोई "मृत कोड" नहीं है), और पूरी तरह से युग्मित तारों के लिए [[[0]] और गैर-पूरी तरह से मिलान किए गए तारों के लिए [['1]] आउटपुट :

ΔγεDgÉ£}JJ}ĀĀ£ÉgDεγΔ 

और 22-बाइट संस्करण, समझाया गया है, जो उपरोक्त है, लेकिन यूबी को गाली नहीं दे रहा है, और समझदार मूल्यों का पालन करता है।

ΔγεDgÉ£}JJ}ĀqqĀ£ÉgDεγΔ – Full program.
Δ         }            – Until fixed point is reached (starting from the input value):
 γε    }                 – Group equal adjacent values, and for each chunk,
   DgÉ                     – Duplicate, get its length mod by 2.
      £                    – And get the first ^ characters of it. This yields the
                             first char of the chunk or "" respectively for odd-length
                             and even-length chunks respectively.
         JJ                – Join the result to a string, but do this twice to help
                             us with the source layout, saving 2 bytes.
            Ā           – Check if the result is an empty string.
             q          – Terminate the execution. Any other commands are ignored.
              qĀ£ÉgDεγΔ – Mirror the part of the program that isn't otherwise removed
                          anyways. This part forgoes }JJ} because that substring will
                          always be trimmed by the algorithm anyway.

Answer 4

क्यूबिक्स , 54 बाइट्स

U#;!u1@.Oi>??>i..??O.@1^^...u--u.u!ww;..#..U..;..;!^^!

यदि स्ट्रिंग पूरी तरह से युग्मित है और नहीं तो आउटपुट कुछ भी 1नहीं है।
इसे यहाँ आज़माएँ

Cubified

      U # ;
      ! u 1
      @ . O
i > ? ? > i . . ? ? O .
@ 1 ^ ^ . . . u - - u .
u ! w w ; . . # . . U .
      . ; .
      . ; !
      ^ ^ !

व्याख्या

अधिकांश पात्रों को कोड को पूरी तरह से जोड़ने के लिए फिलर की आवश्यकता होती है। उन .(नहीं सेशन) की जगह, हम प्राप्त करते हैं

      U # ;
      ! u 1
      @ . O
i . ? . > i . . ? . . .
. . ^ . . . . u - . . .
. . . w ; . . . . . . .
      . ; .
      . ; !
      ^ ^ !

इसे तीन चरणों में तोड़ा जा सकता है:

• खाली स्ट्रिंग (बाएं iऔर ?) के खिलाफ जांचें ।
• लूप, स्टैक पर पात्रों को फेंकना और डुप्लिकेट को पॉप करना (नीचे और दाएं पर सब कुछ)।
• जांचें कि क्या स्टैक खाली है (शीर्ष पर सामान)।

Answer 5

वी , 20 , 18 बाइट्स

òóˆ±òø‚

::‚øò±ˆóò

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

Hexdump:

00000000: f2f3 88b1 f2f8 820a 0a3a 3a82 f8f2 b188  .........::.....
00000010: f3f2                                     ..                   ....

सत्य के लिए आउटपुट 0, मिथ्या के लिए 1। अप्रत्यक्ष रूप से 2 बाइट बचाने के लिए nmjcman101 का धन्यवाद।

ò        ò        " Recursively...
 ó                "   Remove...
  <0x88>          "     Any printable ASCII character
        ±         "     Followed by itself
          ø       " Count...
           <0x82> "   The number of non-empty strings

::<0x82>øò±<0x88>óò      " NOP to ensure that the code is paired

Comments

आप के ^$साथ बदल सकते हैं .और सच के लिए 0 वापस कर सकते हैं , झूठा के लिए कुछ और? मैं थोड़ी देर के लिए ऐसा नहीं करने के बाद नियमों पर थोड़ा धूमिल हूं।

— nmjcman101

मुझे लगता है कि यह काम करेगा सिवाय इसके कि नियम ने कहा कि आप उस मामले के लिए दो अलग-अलग मूल्यों को आउटपुट कर सकते हैं जहां इनपुट पूरी तरह से जोड़ा गया है और अन्यथा के लिए एक है। । यही कारण है कि मुझे एक विचार है, हालांकि देता है ...

— DJMcMayhem

Answer 6

आर , 142 126 बाइट्स

तंग तर्क और कुछ टिप्पणी @Giuseppe द्वारा गोल्फ बाइट

f=function(x,p="(.)\\1")"if"(grepl(p,x),f(sub(p,"",x)),!nchar(x))##x(rahcn!,x,,p(bus(f,)x,p(lperg("fi")"1\\).("=p,x(noitcnuf=f

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

f=function(x,p="(.)\\1")"if"(nchar(x),"if"(grepl(p,x),f(sub(p,"",x)),0),1)##)1,)0,xp(bus(f,)x,p(lperg("fi",)x(rahcn("fi")"1).("=p,x(noitcnuf=f

मूल:

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

पुनरावर्ती डिटेक्टर फ़ंक्शन, रिवर्स ऑर्डर में फ़ंक्शन के सभी पात्रों के साथ टिप्पणी करता है।

Comments

आपका कोड वर्तमान में एक त्रुटि फेंकता है। यहाँ 142 बाइट्स पर एक कार्यशील संस्करण है।

— २०

धन्यवाद। कट-एंड-पेस्ट मिस्सप रहा होगा।

— एन जी एम

126 बाइट्स - आप टिप्पणी को कुछ और भी संक्षिप्त कर सकते हैं ...

— Giuseppe

मैं सोच रहा हूं कि क्या `\\। सरल होगा या टिप्पणियों में नक़ल करने की आवश्यकता होगी।

— JayCe

@JayCe आपको लगता है कि इसे टिप्पणियों में रहने की आवश्यकता नहीं होगी, लेकिन यह कोशिश करें और यह काम नहीं करता है। मुझे पता नहीं क्यों।

— एन जी एम

Answer 7

APL (Dyalog) , 38 बाइट्स

''≡{'(.)\1'⎕R''⊢⍵}⍣≡⍝⍝≡⍣}⍵⊢R⎕'1\).('{≡

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

Answer 8

रेटिना , 28 26 बाइट्स

+`(.)\1

C`^$

$^`C1\).(`+

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

`C1\).(`+0`C1\).(`+झूठा और `C1\).(`+1`C1\).(`+सच्चाई मामलों के लिए आउटपुट ।

Answer 9

ब्रेन-फ्लैक , 228 200 बाइट्स

(()){{{}([]<<{{(({}<<>>)<<>>[({})]){{{{}(<<<<>>()>>)((<<>>))}}}{}{}<<>>{}<<>>}}{}<<>>>>[[]])}}{}(<<({{(())(<<()>>)}}<<>>)>>){{{{}{}}((){{}{}{}{}{}}(()())())[[]((){{}{}}())[]]((){{}{}}[[][]]()){{}{}}}}

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

यह अवधारणा का एक सा प्रमाण है। यह शायद कम हो सकता है। हालांकि यह किसी भी टिप्पणी का उपयोग नहीं करता है।

0,0इनपुट पूरी तरह से युग्मित होने पर आउटपुट देता है और 0,1यदि इनपुट नहीं है।

Answer 10

sed 4.2.2 , 34 बाइट्स

:;:t;ss((..??\??))\1ss1;t;/..??/cc

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

जोड़ी वाले तार खाली आउटपुट देते हैं, अनपढ़ लोग देते हैं ct:

तुच्छ palindromic संस्करण 32 पर है :;ss(.)\1ss;t;/./cc/./;t;1\).(;:। पुराना हल था :;ss((..??\??))\1ss1;t;;/./cc/./t:(वर्तमान में cकम दुरुपयोग के कारण बदला गया , संपादित करें: अब आपके पास केवल 1 वर्ण है c: D)

(ध्यान दें कि ;स्टेटमेंट सेपरेटर है)

: एक खाली लेबल की घोषणा करता है

:t लेबल की घोषणा करता है t

ss((..??\??))\1ss1एक प्रतिस्थापन है, sed में आप एक प्रतिस्थापन के लिए सीमांकक को बदल सकते हैं, और यह मैंने इसे बदलकर किया है s, इसलिए यह क्या करता है पहला स्थानापन्न है (जैसा 1कि अंत में दर्शाया गया है )

• का मैच ((..??\??))\1

  • . कोई भी चरित्र
  • .?? एक वैकल्पिक वैकल्पिक चरित्र के बाद
  • \?? और एक वैकल्पिक ?
  • इसके बाद उसी चीज़ के पास

• किसी के साथ नहीं

अब इस प्रतिस्थापन को अपने साथ जोड़ा जाता है, इसलिए ;पहले और बाद में एस भी रद्द हो जाता है

t और लेबल पर वापस लौटें जब तक कि अधिक सफल प्रतिस्थापन न हों

/..?/यदि .(वाइल्डकार्ड) उसके बाद .?एक वैकल्पिक वर्ण से मेल खाता है

• cc बफर को बदलें c

Answer 11

ब्रेन-फ्लैक , 112 110 108 बाइट्स

(()){{}({<<(({}<<>>)<<>>[({})]){{((<<>>)<<>>)}}{}{##{

}<<>>>>{}<<>>}<<>>)}{}((){{<<>>[[]]}})##}{}])}{([)}(}

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

इस पर आधारित है मेरा उत्तर से कोष्ठक मिलान किया जाता है? ।

टिप्पणियों का उपयोग न करने की कोशिश की, लेकिन पॉप निलाड्स ( {}) जोड़ी बनाने की कोशिश में फंस गए। समस्या सबसे आसान तरीका है कि एक जोड़ी कोष्ठक की जोड़ी को उसी तरह की दूसरी जोड़ी में घेरना है। जबकि अन्य निलाड के लिए यह आसान है, मोनड {...}लूप बनाता है। लूप से बाहर निकलने के लिए आपको एक 0 पुश करना होगा, लेकिन एक बार जब आप लूप से बाहर निकल जाते हैं, तो आपको 0 को पॉप करना होगा, जो समस्या को कंपाउंड करता है।

66 बाइट पूर्व युग्मित समाधान है:

(()){{}({<(({}<>)<>[({})]){((<>)<>)}{}{}<>>{}<>}<>)}{}((){<>[[]]})

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

आउटपुट 1या 1,0यदि इनपुट एक संपूर्ण युग्मन है, 0,0यदि नहीं।

कोई टिप्पणी संस्करण, 156 बाइट्स

(()){{{}({<<(({}<<>>)<<>>[({{}((<<[[]]>>)){}}{}(<<[]>>){{}{}}{})]){{((<<>>)<<>>)}}{{}{}{}}{}{}<<>>>>{}<<>>}<<>>)}}{{}{}}{}((){<<>>[[]]})(<<()()>>){{}{}{}}{}

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

जैसा कि कैट विजार्ड ने कहा है, पहला उत्तर सभी दुभाषियों के लिए काम नहीं करता है, जैसा कि सभी #टिप्पणियों को संभालना नहीं है । इस संस्करण में कोई टिप्पणी नहीं है।

Comments

ध्यान दें कि यह केवल रूबी ब्रेनफ्लैक दुभाषिया में काम करता है और इस तरह एक शुद्ध ब्रेनफ्लक उत्तर नहीं है

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

@CatWizard क्या एक कैनन ब्रेन-फ्लैक दुभाषिया है? जहां तक ​​मुझे पता है, रेन-फ्लैक (रूबी) मूल दुभाषिया है। (इसके अलावा, मैं टिप्पणियों के बिना एक समाधान पर काम कर रहा हूं)

— जो राजा

ज़रुरी नहीं। रेन-फ्लैक मूल दुभाषिया है, लेकिन यह टिप्पणी है कि वाक्यविन्यास इसके लिए अद्वितीय है। हमने कुछ समय पहले एक ब्रेन-फ्लैक मानक लिखा था, मुझे याद नहीं है कि यह कहाँ समाप्त हुआ था।

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

@CatWizard ने कोई टिप्पणी संस्करण समाप्त नहीं किया

— जो किंग

Answer 12

जाप, 24 22 बाइट्स

आउटपुट falsetruthy के लिए और truefalsey के लिए।

&&!!e"(.)%1"PP"1%).("e

कोशिश करो

Comments

चाहेंगे «e"(.)%1काम करते हैं?

— ओलिवर

@ ओलिवर, यही वह है जो मूल रूप से स्रोत प्रतिबंधों से पहले मेरे ध्यान में लाया गया था। «हालांकि, इसके साथ काम करने का तरीका जानने की कोशिश करना , हालांकि।

— शैगी

@Oliver, यह काम नहीं करता है उदासी,।

— झबरा

मुझे लगता है कि आप चुनौती के प्रतिबंधित स्रोत / स्रोत-लेआउट भाग को याद कर सकते हैं , @ ऑलिवर।

— शैगी

मैंने किया ... मेरा बुरा।

— ओलिवर

Answer 13

ब्रेन-फ्लैक , 96 बाइट्स

{<<>>(({})<<>>[(([{}<<>>]))]){((<<[[]]>>))}{}{}{}{}<<>>}<<>>{{{}{}{}{}{}}((<<>>){{}{}}){{{}}}}{}

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

आउटपुट कुछ भी नहीं अगर इनपुट पूरी तरह से युग्मित है, और 0अन्यथा।

गैर-पूरी तरह से युग्मित (मूल) संस्करण:

{<>(({})<>[({}<>)]){((<()>))}{}{}{}<>}<>{((<>))}{}

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

Answer 14

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

null.foldr((%))"";;cc%((r:t))|cc==r=t;;t%s=t:s--s:t=s%=r|t:dlof.un

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

कैट जादूगर ने 6 बाइट्स बचाए।

Comments

66 बाइट्स

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

@CatWizard कुछ प्रभावशाली लंबी दूरी के पतन है।

— xnor

62 बाइट्स

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

Answer 15

++ , 146 बाइट्स जोड़ें

D,g,@~~,L2_|*;;*|_2L,@,g,D
D,ff,@^^,BG€gBF;;FBg€GB,@D1:?:

xx:?

aa:1
`bb
Bxx;;B
Waa*bb,`yy,$ff>xx,`aa,xx|yy,`bb,Byy,xx:yy

O;;O:,B,`,|,`,>$,`,*W`

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

मजेदार तथ्य: स्पष्टीकरण शुरू होने से पहले यह 272 बाइट्स था, अब यह जावा को हरा देता है।

Trueपूरी तरह से संतुलित तारों के लिए आउटपुट , और Falseअन्यथा

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

NB : BFकमांड के साथ एक बग तय किया गया था, जबकि यह जवाब विकास में था।

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

$\mathit{ff}$$g$$\mathit{ff}$$\mathit{ff}$$g$$S$$\mathit{ff}(S)$$S$

$S$$abbbaabacc$$[[a], [bbb], [aa], [b], [a], [cc]]$$g$, और फ़ंक्शन के परिणाम के साथ सब्लिस्ट को बदलें।

$g$$2$$x$$[a]$$[bb]$$[ccc]$

$$[a] \Rightarrow [a, 1]$$ $$[bb] \Rightarrow [b, b, 0]$$ $$[ccc] \Rightarrow [c, c, c, 1]$$

$x$$x > 2$$x - 2$$x$*

$g(s)$$s$BF^D,ff,@^^,$g$$r$$r$;;

$\mathit{ff}$$g$$\mathit{ff}$

• $\mathit{xx}$$\mathit{ff}$
• $\mathit{yy}$$\mathit{ff}$
• $\mathit{aa}$
• $\mathit{bb}$$\mathit{yy}$

$g$$\mathit{xyab}$$g$

€$\mathit{abc}${...}$g${...}$\mathit{gg}$$\mathit{ff}$$g$

D,gg,@~~,L2_|*;;*|_2L,@D             (NB: -2 bytes)
D,ff,@^^,BG€{gg}BF;;FB}gg{€GB,@D?:   (NB: +6 bytes)

जो 4 बाइट्स लंबा है।

$x = 5$$x = 15$

x+10 ; Explicit argument
+10  ; Implicit argument, as x is active

$x$`

$\mathit{ff}$$g$$\mathit{xx}$xx:?$\mathit{xx}$$\mathit{aa}$aa:1$1$$\mathit{xx}$$\mathit{bb}$

`bb
Bxx

$\mathit{bb}$$\mathit{xx}$$\mathit{aa} := 1$$\mathit{bb} := \neg \neg \mathit{xx}$

फिर हम अपने लूप में प्रवेश करते हैं:

Waa*bb,`yy,$ff>xx,`aa,xx|yy,`bb,Byy,xx:yy

एक लूप ऐड ++ में एक निर्माण है: यह चर के बजाय सीधे कोड पर संचालित होता है। कंस्ट्रक्शंस अलग-अलग कोड स्टेटमेंट लेते हैं, ,जिनके साथ वे काम करते हैं। जब और यदि कथन पहले से सीधे एक शर्त रखते हैं, ,जिसमें एकल मान्य कथन शामिल होता है, जैसे कि चर के साथ इन्फिक्स कमांड। एक बात ध्यान दें: सक्रिय चर को शर्त से छोड़ा नहीं जा सकता है।

aa*bb$\mathit{aa}$$\mathit{bb}$$\mathit{yy}$$\mathit{ff}(x)$

`yy,$ff>xx

$\mathit{aa}$

• 1) नया मूल्य पुराने मूल्य के बराबर नहीं है (लूप अद्वितीय होते हुए)
• 2) नया मान रिक्त स्ट्रिंग नहीं है

Add ++ की सबसे बड़ी कमियों में से एक यौगिक कथनों की कमी है, जो एक दूसरे लूप वेरिएबल की आवश्यकता है। हम अपने दो चर प्रदान करते हैं:

$$\mathit{aa} := \mathit{xx} \neq \mathit{yy}$$ $$\mathit{bb} := \neg \neg (\mathit{yy})$$

कोड के साथ

`aa,xx|yy,`bb,Byy

|B $\mathit{xx}$$\mathit{yy}$xx:yy

$\mathit{ff}$$\mathit{aa}$$\mathit{bb}$

$\mathit{aa}$$\mathit{x} = \mathit{y}$$\mathit{aa}$$\mathit{yy}$$\mathit{bb}$$\mathit{aa}$

हम फिर अपने अंतिम विवरण तक पहुँचते हैं:

O

$\mathit{bb}$

• $\mathit{aa} = 1$$\mathit{bb} = \mathrm{False}$$\mathrm{False}$
• $\mathit{aa} = \mathrm{True}$$\mathit{bb} = \mathrm{False}$$\mathrm{False}$
• $\mathit{aa} = \mathrm{False}$$\mathit{bb} = \mathrm{True}$$\mathrm{True}$

$\mathit{bb}$$\mathit{bb}$$\mathrm{True}$$\mathrm{False}$

Answer 16

जावास्क्रिप्ट (ईएस 6), 76 बाइट्स

एक बूलियन देता है।

ff=ss=>ss==(ss=ss.replace(/(.)\1/,''))?!ss:ff(ss)//)(:!?,/1\).(/(ecalper.=(>

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

@ शगुन द्वारा सुझाया गया: 58 बाइट्स पूरी तरह से जोड़े जाने या किसी त्रुटि को फेंकने के लिए एक खाली स्ट्रिंग वापस करके ।

Comments

यदि "रिटर्न मान" में से एक त्रुटि हो सकती है (उस पर पुष्टि की प्रतीक्षा कर रहा है) तो यह 66 बाइट्स हो सकता है ।

— झग्गी

प्रोग्राम एक्सेप्ट कोड के जरिए डिफॉल्ट आउटपुट कर सकते हैं । इस उत्तर के विशेष मामले में, संभावित आउटपुट पूरी तरह से युग्मित स्ट्रिंग्स के लिए कोड 0 से बाहर निकलेंगे और गैर-पूरी तरह से युग्मित स्ट्रिंग्स के लिए कोड 1 से बाहर निकलेंगे , जो दो अलग-अलग मूल्य हैं इसलिए मानदंड को पूरा करते हैं; इसलिए 58 बटर पूरी तरह से वैध होना चाहिए।

— श्री एक्सकोडर

Answer 17

वोल्फ्राम भाषा (गणितज्ञ) , 70 64 बाइट्स

{#//.{aa___,bb__,bb_,cc___}:>{aa,cc}}=={{}}(**(,{>:}_,{.#{&)**)&

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

टिप्पणियों के बिना, 92 बाइट्स

((#//.bb_:>StringReplace[00[ecalpeRgnirtS>aa__:_.#&];bb,{{,}};00>00;00;aa:_~~aa_:>""]))==""&

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

Answer 18

लूआ , 178 बाइट्स

p=...S={}for a in p:gmatch"."do E=S[#S]~=a;S[E and#S+1 or#S]=E and a or X end;print(#S==0)--)0S#(tnirp;dne X ro a dna E=]S#ro 1+S#dna E[S;a=~]S#[S=E od"."hctamg:p ni a rof}{=S.=p

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

हालांकि यह एक बहुत लंबा समाधान है, यह लुआ-विशिष्ट क्विरक्स का काफी उपयोग करता है। यह वास्तव में एक छोटा जानवर बल ढेर एल्गोरिथ्म है। कार्यक्रम को इस तथ्य से जटिल बनाया गया है कि लुआ के पैटर्न जोड़े को बदलने की अनुमति नहीं देते हैं और रेगेक्स में निर्मित नहीं है।

स्पष्टीकरण:

p=... -- command-line argument
S={} -- the stack
for c in p:gmatch"." do -- shorter than "for i=1,#p do ..."
    E=S[#S]~=c -- check whether we have the right letter on top of stack
    -- could've saved some bytes by doing == instead of ~=
    -- but the double negation is necessary for ternary operator
    -- to work with nil values
    S[E and #S+1 or #S]=E and c or X -- Lua's awesome "ternary operator"
end
-- i'm sure there is a better way to output this (table indexing?)
print(#S==0)

Answer 19

गोल> <> , 30 बाइट्स

1ll1**F:}}:{=Q{~~||lzBBzl{Q={F

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

पहले के बाद सब कुछ Bअतिरिक्त कोड है और निष्पादित नहीं किया गया है। एक फ़ंक्शन जो स्टैक के शीर्ष को वापस लौटाता है जैसे 1कि इनपुट एक सही जोड़ी है, 0अन्यथा।

स्पष्टीकरण:

1       Push 1 as the end string marker
 ll1**  Push n, where n (len+1)*(len+2), 
        This is larger than the amount of steps needed to determine pairing
      F           |  Repeat that many times
       :}}:{=        Compare the first two characters of the string
             Q   |   If they are equal
              {~~    Pop both of them
        String is also rotated by 1
        If the string becomes empty, the 1 is compared to itself and removed.
                   lzB   Return whether the length of the stack is 0
                      Bzl{Q={F  Excess code to match unpaired symbols

Answer 20

क्यूबिक्स , 30 बाइट्स

1O@;??;@ii??O;>>;;;..1Wcc1??1W

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

आउटपुट 1अगर स्ट्रिंग पूरी तरह से युग्मित है और अन्यथा कुछ भी नहीं।

Cubified

      1 O @
      ; ? ?
      ; @ i
i ? ? O ; > > ; ; ; . .
1 W c c 1 ? ? 1 W . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

सरलीकृत

      1 O @
      ; ? .
      . @ .
i ? . . . . > ; ; ; . .
. W c . . . ? 1 W . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

तर्क और सामान्य संरचना मेंमनीकोइन के उत्तर के समान हैं, लेकिन खाली स्ट्रिंग के लिए एक स्पष्ट जांच के बिना।

Answer 21

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

gg""

gg((aa:cc:bb))dd|aa==cc=gg bb dd

gg  aa""=""==aa

gg  aa((bb:c))=gg((bb:aa))c--c:=c:|

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

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

@ xnor का जवाब भी बहुत अच्छा है, यह टिप्पणियों का उपयोग करता है और इस से छोटा है।

Answer 22

पायथन 2 , 114 बाइट्स

import re

e=lambda i,nn=1:e(*re.subn('(.)\\1','',i))if nn else''==i##ieslef'1).('(nbus.er*(e:1=,i adbmal=r tropmi

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

Trueपूरी तरह से युग्मित तारों के लिए रिटर्न , Falseअन्यथा।

(वास्तव में खुद को सत्यापित करने में विफल रहता है, क्योंकि (.)कोड में नई सूचियों से मेल नहीं खाएगा! लेकिन @Cat जादूगर ने कहा कि यह ठीक है, क्योंकि newlines मुद्रण योग्य ASCII वर्ण नहीं हैं, इसलिए मेरे कार्यक्रम को उन्हें संभालने की आवश्यकता नहीं है।)

---

यह पूरी तरह से युग्मित संस्करण है:

import re;p=lambda s,n=1:p(*re.subn('(.)\\1','',s))if n else''==i

जिसके लिए एक "lazier" की पूर्णता code + '##' + f(code[::-1])120 बाइट्स देगी। (है कि, चर का नाम बदलने आदि अधिक ढह जोड़े को पेश करने के अंदर टिप्पणी कोड के आधे 6 बाइट्स बचा लिया।)

---

re.subnएक छोटा-सा ज्ञात संस्करण है re.subजो टपल लौटाता है (new_string, number_of_substitutions_made)। यह regex प्रतिस्थापन निर्धारण को खोजने के लिए बहुत अच्छा है!

Answer 23

जेली , 26 24 22 बाइट्स

ẠƬµF€ḂLḣgŒŒgḣLḂ$$€FµƬẠ

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

अजीब तरह से एक अप्रयुक्त लिंक के लिए पीछे की ओर कोड को स्थानांतरित किए बिना काम करने लगता है।

0 रिटर्न अगर इनपुट पूरी तरह से बनती है, तो 1 अन्यथा।

सक्रिय कोड:

ŒgḣLḂ$$€FµƬẠ
Œg            Group runs 'abbbcc'->['a','bbb','cc']
       €      For each of these strings:
      $       Monad{
     $            Monad{
   L                  Find the length...
    Ḃ                 ...mod 2. 
                      } -> [1, 1, 0] in this example.
  ḣ               Take this many characters from the string.
                  } -> [['a'], ['b'], []]
        F     Flatten -> ['a', 'b']
          Ƭ   Repeat...
         µ    The last monadic chain until a fixed point is reached.
           Ạ  All. If it is not a perfectly paired string, all elements in the 
              result of Ƭ will be nonempty and 1 is returned.
              If it is perfectly paired, the last element is [] which is falsy
              and 0 is returned.

Answer 24

अटैची , 82 बाइट्स

{0=#Fixpoint[{Replace[_,/"(.)\\1",""]},_]}??}]_,}],"1).("/,_[ecalpeR{[tniopxiF#=0{

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

यहाँ अविश्वसनीय कुछ भी नहीं। Fixpointसा फंक्शन जो लगातार जोड़े निकालता है।

Answer 25

जावा 8, 158 156 154 बाइट्स

n->{for(;n.matches(".*(.)\\1.*");n=n.replaceAll("(.)\\1",""));return  n.isEmpty();}//};)(ytpmEsi.ruter;,"1).("(Aecalper.n=n;)"*.1).(*."(sehctam.n;(rof{>-n

एक बूलियन ( true/ false) देता है।

-2 बाइट्स @raznagul की बदौलत ।

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

स्पष्टीकरण:

n->{                              // Method with String parameter and boolean return-type
  for(;n.matches(".*(.)\\1.*");   //  Loop as long as the String still contains pairs
    n=n.replaceAll("(.)\\1","")); //   Remove all pairs
  return  n.isEmpty();}           //  Return whether the String is empty now
//};)(ytpmEsi.ruter;,"1).("(Aecalper.n=n;)"*.1).(*."(sehctam.n;(rof{>-n
                                  // Comment reversed of the source code,
                                  // minus the pairs: '\\';'ll';'\\';'""))';'n  n';'//'

Comments

नाम बदलकर उसे sकरने के लिए nऔर एक दूसरे अंतरिक्ष जोड़ने return s.isEmptyआप निकाल सकते हैं s nटिप्पणी से कुल में 2 बाइट्स बचत।

— राजनागुल