fundo

Inspirado por eu sou um palíndromo. Você está?, onde é apresentado o fato chocante de que “ ()()não é um palíndromo, mas ())(”, perguntei-me o que é ()()e a resposta é simplesmente: é uma corda com um eixo de simetria vertical!

A tarefa

Escreva um programa ou função que use uma string S (ou o equivalente apropriado no seu idioma) como entrada, verifique a simetria no eixo vertical e retorne um valor verdadeiro ou falso de acordo. Você pode usar qualquer meio razoável para receber a entrada e fornecer a saída.

Simetria reflexiva

Simetria reflexiva em torno de um eixo vertical (ou simetria esquerda-direita) significa que, se você colocar um espelho verticalmente no centro exato da sequência, a imagem refletida da primeira metade da sequência será idêntica à segunda metade da sequência.

Por exemplo, as seguintes seqüências de caracteres são simétricas de reflexão em torno de um eixo vertical:

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

enquanto o seguinte não é:

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

Regras do concurso

• Seu programa ou função receberá apenas caracteres ASCII imprimíveis. Você pode incluir ou não a sequência vazia (que é simétrica, é claro!) Como entrada legal, o que é melhor para você.

• Os caracteres ASCII que podem ser considerados simétricos em relação aos eixos verticais são os seguintes (observe o espaço inicial e a diferença entre letras maiúsculas e minúsculas):

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

Os caracteres ASCII que podem ser considerados "espelhados" e seus caracteres correspondentes são:

()<>[]{}qpbd/\

Note-se que, uma vez que eles são espelhados, você pode ter os dois (), bem como )(,/\ e \/, etc.

Todos os outros caracteres imprimíveis ASCII devem ser considerados assimétricos e sem um caractere correspondente espelhado.

• Este é um código de golfe desafio do : quanto menor o seu programa, medido em bytes, melhor, em qualquer linguagem de programação.

• Parabéns para as pessoas que produzirão um programa simétrico!

Nota : esta pergunta não é uma duplicata do "Palíndromo Conveniente" , que requer a verificação de cadeias palindrômicas nas quais os parênteses são invertidos. Essa questão é diferente por dois motivos:

1) é uma restrição da outra pergunta no que diz respeito aos caracteres que não estão entre parênteses, uma vez que apenas caracteres simétricos podem aparecer na ordem inversa.

2) Uma vez que é baseado no conceito de simetria, e não em um conceito de “palíndromo conveniente”, caracteres espelhados podem aparecer tanto em ordem, ou seja, []e ][, e isso faz com que o programa para resolvê-lo diferente de programas que resolver o outro problema .

JavaScript (ES6), 130 125 113 bytes

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>

Editar: salvou 5 bytes graças a @Arnauld. Salvou mais 11 bytes graças a @YairRand.

Geléia , 69 62 bytes

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

Experimente online!

Todos os casos de teste

-7 bytes graças a @JonathanAllan

Como funciona

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

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

Economizou 13 bytes graças a Jonathan Allan.

SOGL V0.12 , 88 bytes

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

Experimente aqui!

~ 24 bytes para adicionar qpbdespelhamento e 6 bytes para (x-1 XOR 1) + 1: /

Kotlin 1.1, 201 199 bytes

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

Embelezado

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

Teste

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

Não é possível executar no TIO porque 1.1 não é suportado

Python 2 , 182 167 163 162 160 160 158 bytes

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"

Experimente online!

Guardado 2 bytes graças a Jonathan Allan

Explicação Primeiro, precisamos construir a lista de todos os caracteres que não possuem um simétrico (o próprio caractere:, A... ou outro caractere (para ), ...):

• m("","") retorna uma string com todos os caracteres disponíveis.

• m("","").translate(None," \t!\"'+*-.:=AHIMOTUVWXY^_ovwx|"+t+w)) remove de todos os caracteres disponíveis os caracteres simétricos.

Em seguida, mapeamos cada caractere para seu caractere simétrico e removemos os caracteres que não possuem um simétrico com s.translate(m(t+w,w+t),<chars that don't have a symmetric>)

Se o resultado for igual à sequência invertida, teremos uma sequência simétrica.

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

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

Experimente online!

Scala , 140 bytes

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

Experimente online!