मैं सममित हूं, पैलिंड्रोमिक नहीं!

Question

पृष्ठभूमि

मैं एक पलिंद से प्रेरित हूं। क्या आप? , जहां यह चौंकाने वाला तथ्य प्रस्तुत किया गया है कि " ()()एक तालमेल नहीं है, लेकिन ())(", मैंने खुद से पूछा कि इसके बजाय क्या है ()()और जवाब बस है: यह एक ऊर्ध्वाधर समरूपता अक्ष के साथ एक स्ट्रिंग है!

काम

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

चिंतनशील समरूपता

एक ऊर्ध्वाधर अक्ष (या बाएं-दाएं समरूपता) के चारों ओर परावर्तक समरूपता का मतलब है कि यदि आप स्ट्रिंग के सटीक केंद्र पर एक दर्पण खड़ी करते हैं, तो स्ट्रिंग के पहले छमाही की प्रतिबिंबित छवि स्ट्रिंग के दूसरे छमाही के समान है।

उदाहरण के लिए, निम्नलिखित तार एक ऊर्ध्वाधर अक्ष के चारों ओर परावर्तक सममित होते हैं:

()()
()()()
[A + A]
WOW ! WOW
OH-AH_wx'xw_HA-HO
(<<[[[T*T]]]>>)
(:)
)-(
())(()
qpqp

जबकि निम्नलिखित नहीं हैं:

())(
((B))
11
+-*+-
WOW ! wow
(;)
qppq

प्रतियोगिता के नियम

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

• ASCII वर्ण जिन्हें ऊर्ध्वाधर अक्षों के संबंध में सममित माना जा सकता है वे निम्नलिखित हैं (प्रारंभिक स्थान पर ध्यान दें, और अपरकेस और लोअरकेस अक्षरों के बीच अंतर):

 !"'+*-.:=AHIMOTUVWXY^_ovwx|

ASCII वर्ण जिन्हें "प्रतिबिंबित" माना जा सकता है और उनके संगत वर्ण हैं:

()<>[]{}qpbd/\

ध्यान दें कि, चूंकि वे प्रतिबिंबित हैं, इसलिए आपके पास दोनों ()और साथ ही )(, /\और \/आदि हो सकते हैं ।

अन्य सभी ASCII प्रिंट करने योग्य वर्णों को असममित माना जाना चाहिए और बिना संबंधित चरित्र को प्रतिबिंबित किए।

• यह एक कोड-गोल्फ चुनौती है: आपका प्रोग्राम जितना छोटा है, बाइट्स में मापा जाता है, किसी भी प्रोग्रामिंग भाषा में बेहतर है।

• कुडोस लोगों के लिए जो एक सममित कार्यक्रम का उत्पादन करेंगे!

नोट : यह प्रश्न "सुविधाजनक पैलिंड्रोम" का डुप्लिकेट नहीं है , इसके लिए पैलिंड्रोमिक स्ट्रिंग्स की जांच करनी होती है जिसमें कोष्ठक फ़्लिप होते हैं। यह प्रश्न दो कारणों से अलग है:

1) यह गैर-कोष्ठक वर्णों की चिंता करने वाले अन्य प्रश्न के लिए प्रतिबंध है, क्योंकि केवल सममित वर्ण ही उल्टे क्रम में प्रकट हो सकते हैं।

2) चूँकि यह समरूपता की अवधारणा पर आधारित है, न कि "सुविधाजनक पैलिंड्रोम" की अवधारणा पर, प्रतिबिंबित वर्ण, दोनों क्रम में, []और ][, और यह प्रोग्राम को अलग-अलग समस्याओं को हल करने वाले कार्यक्रमों से अलग करने के लिए बनाता है। ।

Comments

बस किसी को भी आश्चर्य हो रहा है, चारकोल पत्रों को प्रतिबिंबित नहीं करता है। :(

— बिलकुल अमानवीय

मैं द्वैधता से असहमत हूं, क्योंकि द्वैध लक्ष्य पत्रों को प्रतिबिंबित नहीं करता है और यह करता है।

— स्टीफन

क्षमा करें, मैं उदाहरणों से चूक गया, मेरी गलती है

— jrtapsell

8"सममित" क्यों नहीं माना जाता है?

— स्कॉट मिलनर

@FunkyComputerMan यह अनिवार्य रूप से सभी पर लक्ष्य के रूप में ही नहीं है । सबसे पहले और इसके लिए कोई स्रोत कोड प्रतिबंध नहीं है।

— जोनाथन एलन

Answer 1

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

f=
s=>s==[...s].reverse(s=`()<>[]{}qpbd/\\`).map(c=>s[s.indexOf(c)^1]||/[- !"'+*.:=AHIMOT-Y^_ovwx|]/.exec(c)).join``

<input oninput=o.textContent=f(this.value)><pre id=o>

संपादित करें: @Arnauld के लिए 5 बाइट्स सहेजे गए। @YairRand की बदौलत एक और 11 बाइट्स बचाए।

Comments

आप के बजाय एक regexp का उपयोग कर सकते हैं includes()? इस तरह के रूप में /[- !"'+*.:=AHIMO^_ovwx|T-Y]/.test(c)।

— Arnauld

@ अरनल्ड वास्तव में, यह रेंज बहुत मददगार है, धन्यवाद!

— नील

आप गोल्फ कर सकते हैं [...s].reverse().map(...): s::[].map().reverse()यदि आप नई ES-next सुविधाओं का उपयोग करके ठीक हैं। लिंक

— डाउगोएट सेप

@Downgoat क्या आपके पास उस सुविधा की कल्पना के लिए लिंक है?

— नील

यहाँ

— डाउनगेट

Answer 2

जैली , 69 62 बाइट्स

“(<[{qb/“ !"'+*-.:=AHIMOTUVWXY^_ovwx|“)>]}pd\”,Ṛ$F©f@ð®œs2¤yU⁼

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

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

-7 बाइट्स @JonathanAllan को धन्यवाद

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

“(<[{qb/“ !"'+*-.:=AHIMOTUVWXY^_ovwx|“)>]}pd\”,Ṛ$F©f@ð®œs2¤yU⁼  main link

“(<[{qb/“ !"'+*-.:=AHIMOTUVWXY^_ovwx|“)>]}pd\”  The literal list of strings  ['(<[{qb/', ' !"\'+*-.:=AHIMOTUVWXY^_ovwx|', ')>]}pd\\']
               $                 Last two links (if not part of an LCC) as a monad 
            Ṛ                    Reverse array Does not vectorize.
           ,                     Pair; return [x, y].
                 ©               Copy link result to register (® atom to retrieve). 
              F                  Flatten list.
                  f              Filter; remove the elements from x that are not in y.
                   @             Swaps operands. 

                    ð            Start a new dyadic chain
                         ¤       Nilad followed by links as a nilad. 
                      2          The literal integer 2
                   ®             Restore; retrieve the value of the register. Initially 0.
                    œs           Split x into y chunks of similar lengths.
                          y      Translate the elements of y according to the mapping in x.
                           U     Upend; reverse an array.
                            ⁼    Equals. Does not vectorize.

Comments

एक फिल्टर का उपयोग करके छह बाइट्स बचाएं: ¢FiЀ;1Ạðaµ¢yU⁼->¢Ff@ð¢yU⁼

— जोनाथन एलन

रजिस्टर का उपयोग करके एक और सहेजें (सभी अब एक पंक्ति पर):...}pd\”,Ṛ$Fœs©2Ff@ð®yU⁼

— जोनाथन एलन

(... हालांकि एक ही लंबाई ...}pd\”,Ṛ$F©f@ð®œs2¤yU⁼में यकीनन अच्छा है)

— जोनाथन एलन

सममित सेट से आसन्न अध्यादेशकों में से प्रत्येक जोड़ी के लिए केवल एक एन्कोडिंग द्वारा एक और बाइट बचा पाया गया (बेहतर कोड के साथ हटाए गए टिप्पणी को संपादित करें)

— जोनाथन एलन

Answer 3

पायथन 3, 211 208 195 बाइट्स

lambda S,p="()<>[]{}qpbd\/",s=" !\"'+*-.:=AHIMOTUVWXY^_ovwx|":(S==S.translate({ord(s[2*x]):s[2*x+1]for s in(p,p[::-1])for x in range(7)})[::-1])*(~len(S)%2*s[len(S)//2]in s)*(not set(S)-set(p+s))

जोनाथन एलन के लिए धन्यवाद, 13 बाइट्स सहेजे गए।

Comments

9 बाइट्स बचाएं : 1. स्लैश का रिवर्स ऑर्डर ताकि बचने की कोई आवश्यकता न हो; 2. उपयोग 2*xऔर range(7); 3. >2परीक्षण से बचने के लिए गुणा का उपयोग करें ; 4. उपयोग पर नहीं बिटवाइज़ len(S)से बचने के लिए notकी not len(S)%2; 5. तथ्य यह है कि का उपयोग ''in'blah'है Trueस्ट्रिंग गुणा अनुमति देने के लिए ~len(S)%2*s[len(S)//2]in s।

— जोनाथन एलन

सहेजें 4 अधिक इनलाइन करने के लिए सब कुछ

— जोनाथन एलन

Answer 4

SOGL V0.12 , 88 बाइट्स

"el²┘N!←8mYdDm⁵╔C⅛┌6▼ģη⁷fņ‘;W‽0←}C
l»{Kα}lalh=‽;KCø;{:↔³↔=?"qpbd”⁴²+:GW:2%«H+W}:h=?:CΚ}=

यह कोशिश करो!

~ 24 बाइट्स qpbdमिररिंग जोड़ने के लिए और 6 बाइट्स के लिए (x-1 XOR 1) + 1: /

Answer 5

कोटलिन 1.1, 201 199 बाइट्स

{var R="(<[{qb/\\dp}]>)"
var m=HashMap<Any,Any>()
"\"!'+*-.:=AHIMOTUVWXY^_ovwx| ".map{m[it]=it}
R.indices.map{m[R[it]]=R[R.length-(it+1)]}
it.zip(it.reversed()).filter{m[it.first]!=it.second}.none()}

सजा हुआ

{
    var R = "(<[{qb/\\dp}]>)"
    var m = HashMap<Any, Any>()
    "\"!'+*-.:=AHIMOTUVWXY^_ovwx| ".map { m[it] = it }
    R.indices.map { m[R[it]] = R[R.length - (it + 1)] }
    it.zip(it.reversed()).filter { m[it.first] != it.second }.none()
}

परीक्षा

var i:(String)->Boolean =
{var R="(<[{qb/\\dp}]>)"
var m=HashMap<Any,Any>()
"\"!'+*-.:=AHIMOTUVWXY^_ovwx| ".map{m[it]=it}
R.indices.map{m[R[it]]=R[R.length-(it+1)]}
it.zip(it.reversed()).filter{m[it.first]!=it.second}.none()}
fun main(args: Array<String>) {
    var GOOD = listOf("()()",
            "()()()",
            "[A + A]",
            "WOW ! WOW",
            "OH-AH_wx'xw_HA-HO",
            "(<<[[[T*T]]]>>)",
            "(:)",
            ")-(",
            "())(()",
            "qpqp")

    var BAD = listOf("())(",
            "((B))",
            "11",
            "+-*+-",
            "WOW ! wow",
            "(;)",
            "qppq")

    GOOD.filterNot { i(it) }.forEach { throw AssertionError(it) }
    BAD.filter { i(it) }.forEach { throw AssertionError(it) }
    println("Test Passed")
}

TIO पर नहीं चल सकता क्योंकि 1.1 समर्थित नहीं है

Comments

आप इसे केवल 1.0 HashMap आयात करके ऑनलाइन

— सीएडी 97

क्या मेरा स्कोर आयात के साथ या उसके बिना होगा?

— jrtapsell

चूंकि आयात केवल 1.0 पर काम करने के लिए इसे प्राप्त करने के लिए एक शिम है, जहां यह 1.1 पर काम करता है, इसलिए जब तक उत्तर 1.1 निर्दिष्ट करता है कि आप आयात के बिना स्कोर करेंगे। मैं एक नोट डालूंगा, हालांकि, अगर किसी को नहीं पता है कि HashMap (प्रभावी रूप से) 1.1 में स्वचालित रूप से आयात किया गया है।

— CAD97

Answer 6

पायथन 2 , 182 167 163 162 160 158 बाइट्स

lambda s:s[::-1]==s.translate(m(t+w,w+t),m("","").translate(None," !\"'+*-.:=AHIMOTUVWXY^_ovwx|"+t+w))
from string import*
m=maketrans
t=")>[{/qd"
w="(<]}\pb"

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

जोनाथन एलन के लिए 2 बाइट्स को सहेजा गया

स्पष्टीकरण सबसे पहले, हमें उन सभी वर्णों की सूची बनाने की जरूरत है, जिनमें सममित (चार ही नहीं: A..., या किसी अन्य वर्ण के (लिए )...):

• m("","") सभी उपलब्ध वर्णों के साथ एक स्ट्रिंग लौटाता है।

• m("","").translate(None," \t!\"'+*-.:=AHIMOTUVWXY^_ovwx|"+t+w)) सभी उपलब्ध वर्णों को हटा देता है जिसमें एक सममिति होती है।

फिर, हम प्रत्येक चार्ट को उसके सममित चार को मैप करते हैं और उन वर्णों को हटाते हैं जिनके साथ सममित नहीं है s.translate(m(t+w,w+t),<chars that don't have a symmetric>)

यदि परिणाम उलट स्ट्रिंग के बराबर है, तो हमारे पास एक सममित स्ट्रिंग है।

Comments

यदि आप स्लैश को दाईं ओर से स्थानांतरित करते हैं tऔर wआप पलायन को रोक सकते हैं, जैसे w="(<]{\pb"। के साथ एक और बाइट सहेजें from string import*;m=maketrans(मैं व्यक्तिगत रूप से एक नई रेखा के लिए जाता हूं जब ;बाइट्स नहीं बचाता है)। इसके अलावा, आपको फ़ंक्शन को नाम देने की आवश्यकता नहीं है क्योंकि यह पुन: प्रयोज्य है और पुनरावर्ती नहीं है, जो एक और 2 बचाता है।

— जोनाथन एलन

इसके अलावा, आपको फ़ंक्शन को तब तक नाम देने की आवश्यकता नहीं है जब तक यह पुन: प्रयोज्य और पुनरावर्ती नहीं है, जो एक और 2 टीआईओ बचाता है (ध्यान दें: आपके द्वारा सूचीबद्ध कोड और आपके लिंक पर 162 बाइट्स हैं)

— जोनाथन एलन

@JonathanAllan धन्यवाद मैंने पहले ही दो बाइट्स (मानसिक रूप से) को हटा दिया था f=, लेकिन आपका संस्करण क्लीनर है।

— जफरार्ड

Answer 7

पर्ल 5 , 102 + 1 (-पी) = 103 बाइट्स

$_=!/[^ !"'+*.:=AHIMOT-Y^_ovwx|()<>[\]{}qpbd\/\\-]/&&$_ eq reverse y|()<>[]{}qpbd/\\|)(><][}{pqdb\\/|r

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

Answer 8

स्काला , 140 बाइट्स

s.zip(s.reverse).forall(c=>(" !\"'+*-.:=AHIMOTUVWXY^_ovwx|".flatMap(x=>x+""+x)+"()<>[]{}qpbd/\\\\/dbpq}{][><)(").indexOf(c._1+""+c._2)%2==0)

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