背景

受到我的回文启发。你是？在这里，令人震惊的事实是“ ()()不是回文，而是())(”，我问自己是什么()()，答案很简单：它是具有垂直对称轴的字符串！

任务

编写一个程序或函数，该程序或函数将字符串S（或您的语言中适当的等效语言）作为输入，检查沿垂直轴的对称性，并相应地返回真实或虚假值。您可以使用任何合理的方式获取输入并提供输出。

反射对称

围绕垂直轴的反射对称性（或左右对称）意味着，如果将镜子垂直放置在字符串的确切中心，则字符串前半部分的反射图像与字符串后半部分相同。

例如，以下字符串围绕垂直轴反射对称：

()()
()()()
[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）因为它基于对称性概念，而不是基于“方便回文”的概念，所以镜像字符可以同时出现，即[]和][，这使得解决该问题的程序不同于解决其他问题的程序。

的JavaScript（ES6），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个字节。

果冻，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.

Python 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个字节。

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：/

科特林 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")
}

由于不支持1.1，因此无法在TIO上运行

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

如果结果等于反向字符串，则我们有一个对称字符串。

Perl 5，102 +1（-p）= 103字节

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

在线尝试！

斯卡拉 140字节

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

在线尝试！