"सुविधाजनक palindrome" चेकर

Question

यदि आपने पहले कभी palindromic कोड लिखने की कोशिश की है, तो आपको पता होगा कि आपके रास्ते में कितने कोष्ठक आते हैं। ()()नहीं विलोमपद है, भले ही यह थोड़े लगता है कि यह होना चाहिए, जबकि है ())(और ()(दोनों मुरजबंध संबंधी और दोनों बहुत गूंगा देख रहे हैं। क्या यह सुविधाजनक नहीं होगा अगर यह चारों ओर का दूसरा रास्ता था?

यदि कोई स्ट्रिंग उसके व्युत्पन्न सभी कोष्ठक ( ), कोष्ठक ( ), और ब्रेसिज़ ( ) फ़्लिप के बराबर है, तो एक स्ट्रिंग आसानी से पैलिंड्रोमिक है । कोई अन्य वर्ण विशेष नहीं है और इसके लिए फ़्लिपिंग की आवश्यकता होती है। ( कभी-कभी युग्मित होते हैं लेकिन अक्सर ऐसा नहीं होता है इसलिए उन्हें छोड़ दिया जाता है।)()[]{}<>

आपका कार्य लिखना है, आपकी भाषा में, एक प्रोग्राम (एसटीडीआईएन पर इनपुट लेना) या एक फ़ंक्शन (एकल स्ट्रिंग तर्क लेना) जो (ए) एक सुसंगत वास्तविक मूल्य देता है * जब इसका तर्क सुविधाजनक रूप से अस्पष्ट और एक अलग, लगातार गलत होता है मूल्य अन्यथा, और (बी) अपने आप में सुविधाजनक है।

उदाहरण के लिए, निम्नलिखित इनपुट सुविधाजनक रूप से स्पष्ट हैं:

racecar
(a)(bb)(a)
void main(int argc, *char[] argv) {} (vgra []rahc* ,cgra tni)niam diov

और निम्नलिखित नहीं हैं:

non-palindrome
A nut for a jar of tuna?
(old [style] parens) )snerap ]elyts[ dlo(
ingirumimusnocte)etconsumimurigni

आप दुभाषिया / संकलक झंडे को छोड़कर किसी भी बाहरी राज्य (विशिष्ट फ़ाइल नाम, निर्देशिका संरचना, अन्य उपयोगकर्ता इनपुट, वेब एक्सेस, आदि) पर भरोसा नहीं कर सकते हैं।

इसके अलावा, आप "कमेंट ट्रिक" का उपयोग नहीं कर सकते हैं जहाँ आप टिप्पणी करते हैं या अपनी भाषा की कमेंटरी सुविधाओं का लाभ उठाकर अनुपयोगी किसी कोड को प्रस्तुत करते हैं। उदाहरण के लिए, निम्नलिखित में से सभी की अनुमति नहीं है, क्योंकि उनमें गैर-कार्यात्मक भाग होते हैं जिन्हें सुरक्षित रूप से हटाया जा सकता है या नष्ट कर दिया जा सकता है (सुविधापूर्वक हार-जीत के खर्च पर)

{some code} // {edoc emos}
{some code} NB.BN {edoc emos}
"n\" ;{edoc emos} ;"; {some code}; "\n"

जाहिर है कि यह इस तरह के हर मामले को कवर नहीं कर सकता है, लेकिन यहां चुनौती की भावना तालमेल और असत्य ** कोड का उपयोग नहीं करना है, बजाय सही परेड और कोष्ठक का उपयोग करने के लिए। मैं तुम्हें देख रहा हूँ, LISP, Brainfuck।

यह एक कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है, लेकिन कोड की सभी लंबाई का स्वागत है।

* ^{लगातार सच्चे और झूठे मूल्यों से मेरा मतलब है कि आप किसी एक मूल्य की वापसी कर सकते हैं, जैसे कि 1सत्य के लिए और 0असत्य के लिए, या Falseसत्य के लिए और "no"असत्य के लिए, इसलिए जब तक ये मूल्य एक दूसरे से भिन्न होते हैं, और नहीं अपने प्रोग्राम के रन से बदलें। जो भी आपके पात्रों को बचाता है उसका उपयोग करें।}

** ^{अप्रकाशित के साथ भ्रमित नहीं होना : कोड जो मान्य है और अजीब चीजें कर सकता है लेकिन कभी भी ठीक नहीं कहा जाता है।}

Comments

चीजों if(false){some code}या अप्रयुक्त चर के बारे में क्या ? क्या उन्हें अनुमति है?

— ace_HongKongIndependence

@ace यदि आपकी भाषा किसी प्रकार के समझौते या वाक्यगत वैधता के लिए अनएक्सपेक्टेड कोड को पार्स या चेक करती है, तो यह ठीक है। यदि यह एक टिप्पणी के लिए समान है क्योंकि आपकी भाषा उस ब्लॉक के अंदर की जांच नहीं करती है, जब यह सिंटैक्स त्रुटि को फेंक देगा यदि यह किया, तो यह ठीक नहीं है। मुझे लगता है कि यदि आप के लिए एक वैध उपयोग मिल सकता है (eslaf)fi, तो आप का उपयोग करने के लिए मिलता है if(false)।

— एल्गोरिथमशार्क

मुझे यह पता लगाने में बहुत लंबा समय लगा कि क्यों ()()नहीं एक पलिंड्रोम है

— मोनिक

क्या कोड को मल्टी-लाइन इनपुट के साथ काम करना है?

— वेंटरो

@ वेंटरो न्यूलाइन्स और कैरिज रिटर्न चरित्र हैं, और उनके पास फ्लिप करने के लिए कोई जोड़ा नहीं है, इसलिए मैं कहूंगा कि वे सामान्य पात्रों के रूप में गिने जाएं।

— एल्गोरिद्मशार्क

Answer 1

जे (60)

(|.-:'())([]][{}}{'&charsub) :: (busrahc&'}{{}][[])(()':-.|)

यह एक फ़ंक्शन है जो एक तर्क लेता है:

   (|.-:'())([]][{}}{'&charsub) :: (busrahc&'}{{}][[])(()':-.|) 'ingirumimusnocte)etconsumimurigni'
0
   (|.-:'())([]][{}}{'&charsub) :: (busrahc&'}{{}][[])(()':-.|) '(a)(bb)(a)'
1

स्पष्टीकरण:

• f :: gfइनपुट पर फ़ंक्शन चलाता है , और यदि यह त्रुटि के बिना लौटता है, तो परिणाम देता है। यदि fविफल रहता है, तो इसके gबजाय चलता है ।

• fयहाँ है (|.-:'())([]][{}}{'&charsub)जो वास्तविक कार्य करता है,:

  • |.: रिवर्स
  • -:: के बराबर है
  • '())([]][{}}{'&charsub: प्रत्येक ब्रैकेट को उसके विरोधी ब्रैकेट के साथ बदलना
• gसमारोह है (busrahc&'}{{}][[])(()':-.|), जो बकवास लेकिन वाक्य रचना मान्य है। busrahcपरिभाषित नहीं है, लेकिन इससे कोई फर्क नहीं पड़ता क्योंकि यह केवल हल किया जाता है जब इसे चलाया जाता है (और यह नहीं चलेगा)।

Comments

आप अपने बदल कर एक चरित्र को बचा सकता है f :: gमें g@-@f। gहुक के समतुल्य होने के (-.|)कारण :आउटपुट -1 हो जाते हैं और क्रमशः सुस्पष्ट पैलिंड्रोमिक के लिए रिक्त सूची और क्रमशः नहीं।

— एल्गोरिथमशार्क

Answer 2

गोल्फक्राफ्ट, 107 91

.4:ab-1:ba=;1
%ba%{...fi@@=
c43.=;)('"([{
}])"'~?~'"([{
}])"')(;=.34c
=@@if...}%ab%
1;=ab:1-ba:4.

न्यूलाइन्स कलात्मक हैं। fi, c43और cnoops हैं, लेकिन पूरे कोड को निष्पादित किया जाता है।

-3-1-1सुविधाजनक palindromes के लिए प्रिंट , -4-1-1अन्यथा। इसे ऑनलाइन आज़माएं!

वैकल्पिक संस्करण, 155 बाइट्स

64 बाइट की लागत पर, इसमें सुधार किया जा सकता है:

0!*1{!}\;:);0:f;0:i;-1:ab;9:ba;
...=;1%ab%{....i@f@@fi@@=@.=@\)
+""'"([{}])"'~+?+~'"([{}])"'""+
(\@=.@=@@if@@f@i....}%ba%1;=...
;ab:9;ba:1-;i:0;f:0;(:;\{!}1*!0

पहले की तरह, पूरा कोड निष्पादित होता है और हर एक बाइट आउटपुट को प्रभावित करता है।

010सुविधाजनक palindromes के लिए प्रिंट , -100अन्यथा। इसे ऑनलाइन आज़माएं!

टेस्ट और उदाहरण

$ base64 > palindrome.gs -d <<< LjQ6YWItMTpiYT07MSViYSV7Li4uZmlAQD1jNDMuPTspKCciKFt7fV0pIid+P34nIihbe31dKSInKSg7PS4zNGM9QEBpZi4uLn0lYWIlMTs9YWI6MS1iYTo0Lg==
$ wc -c palindrome.gs
91 palindrome.gs
$ rev palindrome.gs | tr '([{}])' ')]}{[(' | diff - palindrome.gs
$ echo -n 'r(a[c{"e"}c]a)r' | golfscript palindrome.gs
-3-1-1
$ echo -n 'totallynotapalindrome' | golfscript palindrome.gs
-4-1-1
$
$ base64 > pal.gs -d <<< MCEqMXshfVw7Oik7MDpmOzA6aTstMTphYjs5OmJhOy4uLj07MSVhYiV7Li4uLmlAZkBAZmlAQD1ALj1AXCkrIiInIihbe31dKSInfis/K34nIihbe31dKSInIiIrKFxAPS5APUBAaWZAQGZAaS4uLi59JWJhJTE7PS4uLjthYjo5O2JhOjEtO2k6MDtmOjA7KDo7XHshfTEqITA=
$ wc -c pal.gs
155 pal.gs
$ rev pal.gs | tr '([{}])' ')]}{[(' | diff - pal.gs
$ echo -n 'r(a[c{"e"}c]a)r' | golfscript pal.gs
010
$ echo -n 'totallynotapalindrome' | golfscript pal.gs
-100
$ for i in {1..154}; do head -c $i pal.gs > tmp.gs; tail -c +$[i+2] pal.gs >> tmp.gs
> [ "$(echo -n 'r(a[c{"e"}c]a)r' | golfscript tmp.gs 2> /dev/null)" = "010" ] && echo $i
> done; rm tmp.gs
1
for i in {1..154}; do head -c $i pal.gs > tmp.gs; tail -c +$[i+2] pal.gs >> tmp.gs
>  [ "$(echo -n '42' | golfscript tmp.gs 2> /dev/null)" = "-100" ] && echo $i
> done | grep '^1$'; rm tmp.gs

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

.             # Duplicate the input string.
4:ab-1:ba     # Save 4 in “ab” and -1 in “ba”.
=;            # Compare 4 to -1 and discard the result.
1%            # Save every element from the input string in a new string.
ab%           # Reverse the input string.
{             # For each character in the input string:
  ...         # Duplicate the character thrice.
  fi          # Variable “fi” is undefined; this does nothing.
  @@=         # Verify that the character is equal to itself; push 1.
  c43         # Variable “c43” is undefined; this does nothing.
  .=;         # Verify that 1 is equal to itself and discard the result.
  )(          # Increment and decrement the character.
  '"([{}])"'~ # Push that string and evaluate it. Result: '([{}])'
  ?           # Retrieve the character's position in '([{}])'. -1 means not found.
  ~           # Negate the position.. Examples: -1 -> 0    0 -> -1    2 -> -3
  '"([{}])"') # Push that string and pop its last element. Result: '"([{}])' 34
  (;          # Decrement 34 (the ASCII code of a double quote) and discard.
  =           # Retrieve the corresponding character.
  .34         # Duplicate the character and push 34.
  c           # Variable “c” is undefined; this does nothing.
  =           # If the character is a double quote, the index was -1.
  @@if        # In that case, replace the double quote with the original character.
  ...         # Duplicate the new character thrice.
}%            #
ab%           # Save every fourth element in a new string to discard dummy values.
1;            # Push 1 and discard.
=             # Push 1 if the modified string matches the original, 0 otherwise.
ab:1-         # Save 4 in “1” and subtract.
ba:4.         # Save -1 in “4” and duplicate.

0!*           # Pop and push the input string.
1{!}\;:);     # Make “)” an alias for “!”.
0:f;0:i;      # Variables.
-1:ab;9:ba;   # Moar variables.
...=;         # Duplicate the input string.
1%ab%         # Reverse the copy.
{             # For each character in the input string:
  ....        # Duplicate the character four times.
  i@          # Push 0 and rotate a string copy on top of it.
  f@@fi@@     # Push 0 and rotate 0 on top of it.
  =@          # Push 1 and rotate a string copy on top of it.
  .=@         # Push 1 and rotate 1 on top of it.
  \)+         # Negate a 1 and add. Result: 1
  ""          # Push that string.
  '"([{}])"'  # Push that string.
   ~+         # Evaluate the second string and concatenate. Result: '([{}])'
   ?          # Retrieve the characters position in '([{}])'. -1 means not found.
   +~         # Add 1 to the position and negate. Ex.: -1 -> -1 | 0 -> -2 | 1 -> -3
  '"([{}])"'  # Push that string.
  ""          # Push that string.
  +           # Concatenate. Result: '"([{}])"' 
  (\          # Pop the first double quote and swap it with the rest of the string.
  @=.         # Retrieve the corresponding character and duplicate it.
  @=          # If the character is a double quote, the index was -1.
  @@if        # In that case, replace the double quote with the original character.
  @@          # Rotate the modified character to the bottom.
  f@i....     # Push dummy values.
  }%          #
  ba%         # Save every ninth element in a new string to discard dummy values.
  1;          # Push 1 and discard.
  =           # Push 1 if the modified string matches the original, 0 otherwise.
  ...;        # Duplicate thrice and discard the last copy.
  ab:9;ba:1-; # Variables.
  i:0;f:0;    # Moar variables.
  (:;\        # Negate, override “;” and swap.
  {!}1*!0     # Negate twice and push 0.

Answer 3

रूबी, 110

(z=gets;r=z.tr *["([{}])",")]}{[("];p *z==r.reverse;1)||(1;esrever.r==z* p;[")]}{[(","([{}])"]* rt.z=r;steg=z)

प्रिंट trueयदि इनपुट एक सुविधाजनक पैलिंड्रोम है और falseयदि यह नहीं है। ध्यान दें कि यह समाधान मानता है कि इनपुट एक नई रेखा द्वारा समाप्त नहीं किया गया है, इसलिए इसके साथ परीक्षण करें echo -n:

echo -n '(a)(bb)(a)' | ruby convpal.rb
true

echo -n '(a)(bb()a(' | ruby convpal.rb
false

# note that for this to work, the file must not contain a newline
# to remove a trailing newline, pipe it through tr -d $'\n'
cat convpal.rb | ruby convpal.rb
true

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

इसे एडाप्ट करने में एकमात्र कठिनाई यह पता लगाना था कि कॉल को कैसे जोड़ा z.trजाए ताकि इसकी "सुविधाजनक रिवर्स" भी वाक्यविन्यास रूप से मान्य हो - लेकिन मैं बस उसी ट्रिक का उपयोग कर सकता हूं जिसका मैं पहले से ही उपयोग करता हूं: *जो पहले हाफ में पार्स किया गया है। दूसरे भाग में छप संचालक (फ़ंक्शन मापदंडों के रूप में सरणी सामग्री का उपयोग करें) और सरणी गुणन (या दोहराव) ऑपरेटर के रूप में।

रूबी, 157 297, सभी कोड निष्पादित

w=tsoh=gets p
o=rt=esrever=Gem
q=tsoh.tr *["([{}])",")]}{[("]
q==esrever.host=w=tsoh.reverse==q
[")]}{[(","([{}])"]* rt.host=q
meG=reverse=tr=o
p steg=host=w

यह (थोड़ा लंबा) संस्करण सभी कोड को निष्पादित करता है , और सभी लेकिन दो लाइनें आउटपुट को प्रभावित करती हैं, जो अंतिम पंक्ति में मुद्रित होती है - लेकिन सभी लाइनों को बिना किसी त्रुटि के पार्स और निष्पादित किया जाता है। यह संस्करण इनपुट के भाग के रूप में किसी भी अनुगामी न्यूलाइन की व्याख्या करता है, इसलिए इसका echo -nपरीक्षण करने के लिए या तो प्रयोग करें , या अपने इनपुट को एक नई रेखा के साथ प्रस्तुत करें यह प्रिंट करता है trueयदि इनपुट एक सुविधाजनक पैलिंड्रोम है, और falseअन्यथा।

व्याख्या

# Read the input by calling gets(nil), which is achieved by passing the return
# value of a call to Kernel#p (which returns nil if no argument is supplied) to
# gets.
w=tsoh=gets p
# Assign the global Gem module to three variables.
# The variable names are the reversed names of methods we have to call later.
# This doesn't necessarily have to be the Gem module, any global module/variable
# (or class that allows object creation through a call to the module itself,
# e.g. Hash or GC) with a writable property would do, but Gem#host was
# the shortest one I could find. This is necessary because Ruby doesn't
# allow setting previously undefined properties through the dot syntax.
o=rt=esrever=Gem
# Replace the parentheses with the corresponding flipped one.
# sserts is the reverse of the property name we're going to use later.
q=tsoh.tr *["([{}])",")]}{[("]
# Do the convinient palindrome check and assign its result to a few variables
# and Gem's host property.
q==esrever.host=w=tsoh.reverse==q
# Here, the * is parsed as array join operator.
[")]}{[(","([{}])"]* rt.host=q
# Nothing special here.
meG=reverse=tr=o
# Print the result of the palindrome check, which was stored in w.
p steg=host=w

Answer 4

GolfScript, 61 वर्ण

ठीक है, यहाँ GolfScript में एक आधारभूत समाधान है। मुझे यकीन है कि इसे और बेहतर बनाया जा सकता है:

{.-1%{"([{}])".2$?~@[.]@+=}%=}~{=%{=+@[.]@~?$2."([{}])"}%1-.}

गोल्फस्क्रिप्ट के लिए हमेशा की तरह, यह कार्यक्रम स्टड से इसके इनपुट को पढ़ता है। यह आउटपुट:

1{=%{=+@[.]@~?$2."([{}])"}%1-.}

यदि इनपुट एक सुविधाजनक तालमेल है, जैसा कि ऊपर दी गई चुनौती में परिभाषित किया गया है, और:

0{=%{=+@[.]@~?$2."([{}])"}%1-.}

अगर यह नही तो।

स्पष्टीकरण: यह कार्यक्रम सत्तारूढ़ पर बहुत निर्भर करता है कि जब तक यह पार्स हो जाता है, तब तक अप्रकाशित कोड ठीक है। इसमें दो कोड ब्लॉक होते हैं { }, जो कर्ली ब्रेसिज़ ( ) द्वारा सीमांकित होते हैं , जो एक दूसरे के दर्पण चित्र होते हैं।

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

यह ध्यान दिया जाना चाहिए कि गोल्फस्क्रिप्ट दुभाषिया पार्स समय (या उस मामले के लिए) पर बहुत कम वाक्यविन्यास जांच करता है; एक गोल्फस्क्रिप्ट कोड ब्लॉक शाब्दिक में लगभग कुछ भी हो सकता है, भले ही यह निष्पादित होने पर दुर्घटनाग्रस्त हो सकता है। फिर भी, कुछ वाक्यविन्यास त्रुटियां, जैसे कि असंक्रमित स्ट्रिंग शाब्दिक, अनएक्सपेक्टेड कोड में भी त्रुटि उठाती हैं, इसलिए मेरा मानना ​​है कि यह समाधान (बमुश्किल) नियमों के भीतर आता है।

Ps। वास्तविक निष्पादित कोड को देखते हुए, इसमें कुछ सुविधाजनक पेलिंड्रोमिक तत्व जैसे @[.]@, स्ट्रिंग शाब्दिक "([{}])"और यहां तक ​​कि लूप शामिल हैं %{ ... }%। यह टैंटलाइजिंग सुझाव प्रदान करता है कि "आंतरिक रूप से पैलिंड्रोमिक" गोल्फस्क्रिप्ट समाधान, जहां पूर्ण पैलिंड्रोमिक कार्यक्रम निष्पादित और कार्यात्मक होगा, वास्तव में संभव हो सकता है। जैसा कि मैंने अभी तक एक का उत्पादन करने में खुद को कामयाब नहीं किया है, मैं इसके साथ पहले व्यक्ति को +100 प्रतिनिधि इनाम की पेशकश करता हूं जो एक से ऊपर आने का प्रबंधन करता है!

Comments

रुको, उर कोड एक पैलिंड्रोम ही है? : ओ

— फैब्रिकियो

मैं इस समाधान पर अधिक- "n\";X;";X;"\n"टिप्पणी करने के लिए -इंडियन की तरह विचार करने के लिए इच्छुक हूं , लेकिन मैं आपको संदेह का लाभ दूंगा। मैं वास्तव में इस तरह के "आंतरिक रूप से पैलिंड्रोमिक" समाधानों की तलाश में था, हालांकि, या कम से कम उन लोगों के लिए जहां ब्लॉकों का गैर-निष्पादन थोड़ा और कम था।

— एल्गोरिथमशार्क

मेरे जवाब में एक नोप (अपरिभाषित चर) और कुछ भाग हैं जो कुछ भी नहीं पूरा करते हैं (जैसे, 1;)। क्या यह अभी भी पूरी तरह कार्यात्मक के रूप में गिना जाता है?

— डेनिस

@ डेनिस: हाँ, मुझे लगता है कि यह करता है। बधाई हो, यह निश्चित रूप से काफी प्रभावशाली है। यह सवाल काफी नया लग रहा है कि मैं इस पर अभी तक इनाम नहीं दे सकता, लेकिन कुछ दिनों में आपके पास होगा।

— इल्मरी करोनें

आउटपुट स्वरूप leeway abuuuse :-)

— जॉन ड्वोरक

Answer 5

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

मैं एक जेएस उत्तर चाहता था जिसे ब्राउज़र में चलाया जा सकता है, इसलिए यहां यह है।

eurt=>eurt==(("",eurt))["split"||"nioj"]("")["map"||"esrever"](x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x||[x]({')':'(','(':')',']':'[','[':']','}':'{','{':'}'})>=x)["reverse"||"pam"]("")["join"||"tilps"]((true,""))==true>=true

वास्तव में कभी नहीं चलने वाले सभी कोड को हटाते हुए, हमें यह मिलता है:

eurt=>eurt==(("",eurt))["split"||"nioj"]("")["map"||"esrever"](x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x||[x]({')':'(','(':')',']':'[','[':']','}':'{','{':'}'})>=x)["reverse"||"pam"]("")["join"||"tilps"]((true,""))==true>=true
eurt=>eurt==(("",eurt))["split"        ]("")["map"           ](x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x                                                           )["reverse"       ]("")["join"         ]((true,""))==true>=true

इसे सरल बनाया जा सकता है:

eurt=>eurt==eurt.split("").map(x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x).reverse("").join("")

Comments

आप सही / eurt के बजाय n1 / 1n का उपयोग करके कुछ 60 बाइट्स बचा सकते हैं, कुछ जगह पर कॉमा, || और ब्रैकेट स्विचर के साथ fiddling: n1=>n1==(('',n1))['nioj','split']``['esrever','map'](c=>`()[]{}`[`()[]{}`['indexOf'](c)^1]||c||[1^(c)['fOxedni']`{}[]()`]`{}[]()`>=c)['pam','reverse']``['tilps','join']((1n,''))==1n>=1n(185 बाइट्स)

— Yair Rand

Answer 6

जावास्क्रिप्ट (ईएस 6) 288

Spidermonkey कमांड लाइन शेल में चलता है । एसटीडीआईएन और आउटपुट से एक ही लाइन पढ़ता है trueया यह falseनिर्भर करता है कि इनपुट सुविधाजनक पैलिंड्रोम है या नहीं।

((print)((eval)('r=readline()')==([0]['map']['call'](r,x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x)['reverse']()['join']('')))&&((('')['nioj']()['esrever'](x||[x]({')':'(','(':')',']':'[','[':']','}':'{','{':'}'})>=x,r)['llac']['pam'][0])==('()enildaer=r')(lave))(tnirp))

यह कोड वाक्यविन्यास रूप से मान्य है, लेकिन सब कुछ &&निष्पादित नहीं होने के बाद , क्योंकि printफ़ंक्शन एक गलत मूल्य देता है।

आप का अनुकरण करने के पहले इस शिम चलाकर फायरफॉक्स के कंसोल में इस कोड को चला सकते हैं readlineऔर printकार्य करता है। readlineआवश्यकतानुसार इनपुट संपादित करें :

readline = function(){ 
    return "void main(int argc, *char[] argv) {} (vgra []rahc* ,cgra tni)niam diov"; 
}, print = console.log.bind(console);

और यहाँ आउटपुट का एक त्वरित उदाहरण है:

Comments

&&वास्तव में होशियार होने का फायदा उठाते हुए , मैं आपकी सराहना करता हूं (लेकिन यह एक छोटा धोखा लगता है)

— मेयरमोनी

Answer 7

05AB1E, 35 बाइट्स

"{[()]}"DRr‡`rJ¹Q,Q¹Jr`‡rRD"{[()]}"

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

स्पष्टीकरण:

                     # Implicit input
 "{[()]}"            # Push "{[()]}" onto the stack
         DR          # Pushes a reversed copy onto the stack
           r         # Reverse the order of the stack
            ‡        # Transliterate
             `       # Flatten array on stack
              r      # Reverse order of stack
               J     # Join stack
                ¹Q   # Check equality with first input
                  ,  # Print
                     # Everything after is still syntactically correct, but just does not print anything.

Comments

मुझे नहीं लगता कि यह जवाब अमान्य होने के बाद से मदद करेगा लेकिन इसके बजाय "()[]{}"आप कर सकते हैंžu„<>-

— acrolith

@daHugLenny यह अब वैध है

— ओलिवर नी

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

— एल्गोरिथमशार्क

@algorithmshark फिक्स्ड।

— ओलिवर नी

Answer 8

CJam, 38 बाइट्स

Q~"=re%W_@%W_q"`{[()]}`"q_W%@_W%er="~Q

प्रिंट "=re%W_@%W_q"1यदि इनपुट सुविधाजनक रूप से पैलिंड्रोमिक और "=re%W_@%W_q"0अन्यथा है।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

Q~                                     e# Evaluate an empty string.
  "=re%W_@%W_q"                        e# Push that string.
               `                       e# Inspect. Pushes "\"=re%W_@%W_q\"".
                {[()]}                 e# Push that block.
                      `                e# Inspect. Pushes "{[()]}".
                       "           "~  e# Push and evaluate.
                        q              e# Read from STDIN.
                         _W%           e# Push a reversed copy.
                            @          e# Rotate "{[()]}" on top of the stack.
                             _W%       e# Push a reversed copy.
                                er     e# Perform transliteration.
                                  =    e# Compare to the input string.
                                     Q e# Push an empty string.

कार्यक्रम को निष्पादित करने के बाद, सीजेएम स्वचालित रूप से स्टैक पर सभी तीन वस्तुओं को प्रिंट करता है: निरीक्षण स्ट्रिंग, स्ट्रिंग तुलना से बूलियन और खाली स्ट्रिंग।

Answer 9

पर्ल, 83 + 2 = 85 बाइट्स

साथ दौड़ो -nl

say$_~~reverse y-"({[]})"-")}][{("-r;exit;tixe;r-")}][{("-"({[]})"-y esrever~~_$yas

इनपुट की सत्यता को प्रिंट करने के बाद कोड बाहर निकल जाता है। अर्धविराम के बाद सब कुछ व्याख्या की गई है (और जब दुर्घटना उस बिंदु तक पहुंच जाएगी, तो यह इस बात के लिए नहीं था कि exitउसका सामना होगा), लेकिन निष्पादित नहीं किया गया। यदि मैंने exit;tixe;कोड छोड़ दिया , तो क्रैश होने से पहले ही वह परिणाम को सही ढंग से प्रिंट कर लेगा।