sfondo

Ispirato da Sono un palindromo. Tu sei? , dove si presenta il fatto scioccante che " ()()non è un palindromo, ma ())(", mi sono chiesto cosa sia invece ()()e la risposta è semplicemente: è una stringa con un asse di simmetria verticale!

L'obiettivo

Scrivi un programma o una funzione che accetta come input una stringa S (o l'equivalente appropriato nella tua lingua), verifica la simmetria lungo l'asse verticale e restituisce un valore di verità o falsa di conseguenza. È possibile utilizzare qualsiasi mezzo ragionevole per accettare l'input e fornire l'output.

Simmetria riflessiva

La simmetria riflettente attorno ad un asse verticale (o simmetria sinistra-destra) significa che se si posiziona uno specchio verticalmente nel centro esatto della stringa, l'immagine riflessa della prima metà della stringa è identica alla seconda metà della stringa.

Ad esempio, le seguenti stringhe sono simmetriche riflettenti attorno ad un asse verticale:

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

mentre i seguenti non sono:

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

Regole del concorso

• Il programma o la funzione riceverà solo caratteri ASCII stampabili. Puoi includere o meno la stringa vuota, (che è simmetrica, ovviamente!) Come input legale, che è meglio per te.

• I caratteri ASCII che possono essere considerati simmetrici rispetto agli assi verticali sono i seguenti (notare lo spazio iniziale e la differenza tra lettere maiuscole e minuscole):

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

I caratteri ASCII che possono essere considerati "specchiati" e i loro caratteri corrispondenti sono:

()<>[]{}qpbd/\

Si noti che, poiché sono sottoposti a mirroring, è possibile avere sia ()così come )(, /\e \/, ecc.

Tutti gli altri caratteri stampabili ASCII devono essere considerati asimmetrici e senza un carattere corrispondente speculare.

• Questa è una sfida di code-golf : più breve è il tuo programma, misurato in byte, migliore è, in qualsiasi linguaggio di programmazione.

• Complimenti alle persone che produrranno un programma simmetrico!

Nota : questa domanda non è un duplicato di "Convenient Palindrome" , che richiede di controllare le stringhe palindromiche in cui vengono capovolte le parentesi. Questa domanda è diversa per due motivi:

1) è una restrizione dell'altra domanda per quanto riguarda i caratteri non parentesi, poiché solo i caratteri simmetrici possono apparire in ordine inverso.

2) Dal momento che si basa sul concetto di simmetria e non su un concetto di "comodo palindromo", i caratteri specchiati possono apparire in entrambi gli ordini, cioè []e ][, e questo rende il programma per risolverlo diverso dai programmi che risolvono l'altro problema .

JavaScript (ES6), 130 125 113 byte

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>

Modifica: salvato 5 byte grazie a @Arnauld. Salvati ulteriori 11 byte grazie a @YairRand.

Gelatina , 69 62 byte

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

Provalo online!

Tutti i casi di test

-7 byte grazie a @JonathanAllan

Come funziona

“(<[{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.

Python 3, 211 208 195 byte

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))

Salvato 13 byte grazie a Jonathan Allan.

SOGL V0.12 , 88 byte

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

Provalo qui!

~ 24 byte per aggiungere il qpbdmirroring e 6 byte per (x-1 XOR 1) + 1: /

Kotlin 1.1, 201 199 byte

{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()}

Abbellire

{
    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()
}

Test

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")
}

Impossibile eseguire su TIO perché 1.1 non è supportato

Python 2 , 182 167 163 162 160 158 byte

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"

Provalo online!

Salvato 2 byte grazie a Jonathan Allan

Spiegazione Per prima cosa, dobbiamo costruire l'elenco di tutti i caratteri che non hanno un simmetrico (il carattere stesso:, A... o un altro carattere (per ), ...):

• m("","") restituisce una stringa con tutti i caratteri disponibili.

• m("","").translate(None," \t!\"'+*-.:=AHIMOTUVWXY^_ovwx|"+t+w)) rimuove da tutti i caratteri disponibili i caratteri che hanno un carattere simmetrico.

Quindi, mappiamo ogni carattere al suo carattere simmetrico e rimuoviamo i caratteri che non hanno un carattere simmetrico s.translate(m(t+w,w+t),<chars that don't have a symmetric>)

Se il risultato è uguale alla stringa invertita, abbiamo una stringa simmetrica.

Perl 5 , 102 + 1 (-p) = 103 byte

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

Provalo online!

Scala , 140 byte

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

Provalo online!