Atbash Self Palindromes

27

Considere a transformação Atbash :

A|B|C|D|E|F|G|H|I|J|K|L|M
Z|Y|X|W|V|U|T|S|R|Q|P|O|N

Onde A ⇔ Z e L ⇔ O, por exemplo, existe uma propriedade interessante que algumas palavras compartilham. Quando algumas strings são traduzidas para o equivalente atbash, a tradução é a palavra original invertida. Eu chamo esses auto-palindromes de Atbash .

Como exemplo, vamos traduzir o WIZARD :

W → D
I → R
Z → A
A → Z
R → I
D → W

O resultado é DRAZIW , que é o WIZARD invertido. Assim, o WIZARD é um auto-palíndromo atbash.

Objetivo Dada uma sequência de caracteres ASCII imprimíveis, produza ou retorne um valor verdadeiro se essa sequência for um auto-palíndromo atbash e, caso contrário, um valor falsey. (Isso é feito através do STDIN, equivalente mais próximo, entrada funcional, etc. Se o seu idioma não puder fazer nada disso, considere escolher um idioma diferente, você pode codificar a entrada.) Você deve fazer isso sem distinção de maiúsculas e minúsculas. Se a entrada for um palíndromo e não for afetada pela sequência atbash, você ainda deverá gerar true, pois um palíndromo + em si é um palíndromo. Este é um código de golfe , portanto o programa mais curto em bytes vence.

Casos de teste

"Input" => true, false

"WIZARD" => true
"Wizard" => true // case doesn't matter
"wIzArD" => true 
"W I Z A R D" => true
"W IZ ARD" => false // the atbash of this is D RA ZIW, which is not a palindrome of W IZ ARD
"ABCXYZ" => true // ZYXCBA
"345 09%" => false // is not a palindrome
"ev" => true // ve
"AZGDFSSF IJHSDFIU HFIA" => false
"Zyba" => true
"-AZ" => false // -ZA is not a reverse of -AZ
"Tree vvig" => true // Givv eert 
"$%%$" => true // palindrome
"A$&$z" => true // z$&$A

Entre os melhores

O snippet de pilha na parte inferior desta postagem gera o catálogo a partir das respostas a) como uma lista da solução mais curta por idioma eb) como uma tabela geral de líderes.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

## Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

## Perl, 43 + 2 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostrar snippet de código

code-golf string cryptography palindrome Conor O'Brien
fonte
Relacionado: Troque o alfabeto .
Nicael
4
AtBash não é realmente uma coisa nova. É a transformação da letra hebraica da cabala (misticismo judaico) equivalente a isso. Como o hebraico é escrito apenas com vigas, qualquer sequência de letras pode ser lida inserindo vigas aleatórias. ATB (a) SH é um mnemônico para transformar Alef (primeira letra hebraica) em Tav (último), Beis (segundo) em SHin (penúltimo).
Adám 7/01/16
1
Considere atribuir -1000000 pontos se o código da solução de alguém for um auto-palíndromo atbash? : p
kojiro 07/01
3
@kojiro não-trivial ao contrário code {Comment-symbol}{Atbash'ed Comment-symbol} Atbash'ed code...
Adám
1
@ mbomb007 Eu disse que pode oferecer uma recompensa se tal não trivial programa é encontrado
Conor O'Brien

Respostas:

8

RX , 9 8 bytes

Fortemente inspirado pela Retina, fiz isso alguns dias atrás. Código:

prR`w$rM

Explicação:

prR`w$rM

p         # Start pattern
 r        # Reversed lowercase alphabet
  R       # Reversed uppercase alphabet
   `      # Next pattern
    w     # Equivalent to a-zA-Z_0-9 (word pattern)
     $    # End pattern and compute regex
      r   # Reverse input
       M  # Change mode to Match mode, compares the atbash string with the reversed string.

Experimente aqui !

Adnan
fonte
Então, como a própria linguagem realmente funciona? É algum tipo de linguagem de processamento de string baseada em pilha? Isso é realmente impressionante, mas até onde eu sei, ainda não há como fazer um loop na linguagem, o que significa que é altamente improvável que isso atenda aos nossos padrões de linguagem de programação neste estágio.
Martin Ender
@ MartinBüttner Este idioma é baseado principalmente no processamento da entrada usando um modelo de pilha. Ele não usa números inteiros (e provavelmente nunca o fará). Eu implementei um loop, mas essa versão ainda não foi lançada.
Adnan
@ Martin Regexes são capazes de testar a primalidade por conta própria, por isso tenho certeza que isso é válido.
precisa saber é o seguinte
@ThomasKwa Até onde eu sei, o intérprete não usa nenhuma expressão regular real.
Martin Ender
@ Martin Hmm, você está certo.
precisa saber é
11

Pitão, 10 9 bytes

qJrz0_XJG

Experimente este violino online ou verifique todos os casos de teste de uma só vez.

Explicação

qJrz0_XJG
  rz0      Lowercase input
 J         Store a copy in J
     _XJG  Translate J with the reverse alphabet and reverse
q          Compare
um spaghetto
fonte
3
Como você está usando rz0duas vezes, não é mais curto salvá-lo em uma variável?
Xnor
1
Como o @xnor sugere, q_Jrz0XJGé um byte mais curto.
precisa saber é o seguinte
6

Julia, 96 bytes

s->join([get(Dict(zip([u=map(Char,65:90);],reverse(u))),c,c)for c=(S=uppercase(s))])==reverse(S)

Esta é uma função lambda que aceita uma string e retorna uma string. Para chamá-lo, atribua-o a uma variável.

Ungolfed:

function f(s::AbstractString)
    # Get all of the uppercase letters A-Z
    u = map(Char, 65:90)

    # Create a dictionary for the transformation
    D = Dict(zip(u, reverse(u)))

    # Uppercase the input
    S = uppercase(s)

    return join([get(D, c, c) for c in S]) == reverse(S)
end
Alex A.
fonte
5

Utilitários Bash + Linux, 56

tr a-z `printf %s {z..a}`<<<${1,,}|cmp - <(rev<<<${1,,})

Produz a string vazia para Truthy e algo como - /dev/fd/63 differ: byte 1, line 1para Falsey. Se isso não for aceitável, podemos adicionar -s3 bytes extras e usar os códigos de retorno Unix padrão de 0 para Success (Truthy) e 1 para Failure (Falsey).

Trauma Digital
fonte
5

Retina , 44 bytes

$
¶$_
T`lL`Ro`.+$
+`(¶.*)(.)
$2$1
i`^(.+)\1$

Imprime 1ou 0. A contagem de bytes assume que o arquivo está codificado como ISO 8859-1.

Experimente online!

Essa resposta foi amplamente inspirada na resposta sed da DigitalTrauma, mas, novamente, acho que não existem muitas abordagens para esse desafio em primeiro lugar.

Explicação

Sempre que você vê um , a primeira coisa que o Retina faz depois de dividir o código em linhas é substituir todos os pilrows por feeds de linha. Isso permite a inclusão de feeds de linha para um único byte, embora os feeds de linha sejam o separador de estágio do Retina.

$
¶$_

Começamos duplicando a entrada. Combinamos o final da entrada com $e inserimos um avanço de linha junto com a entrada (usando $_).

T`lL`Ro`.+$

Um estágio de transliteração. Vamos começar com a regex: .+$. Corresponde à segunda cópia da entrada (garantindo que a correspondência vá até o final da sequência). Portanto, apenas os caracteres na segunda cópia serão transliterados. A transliteração em si faz uso de alguns recursos muito recentes. le Lsão classes de caracteres para letras maiúsculas e minúsculas, respectivamente. orefere-se ao outro conjunto de caracteres da transliteração e a Rreverte. Portanto, os dois conjuntos de caracteres se expandem para:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba

Você notará que isso muda o caso ao executar o código Atbash, mas faremos a comparação final sem distinção entre maiúsculas e minúsculas.

+`(¶.*)(.)
$2$1

Agora, invertemos a segunda cópia. Infelizmente, Retina ainda não tem uma maneira conveniente de fazer isso, então teremos que mover um personagem de ponta a ponta de cada vez. Isso é feito redirecionando o separador de avanço de linha como um marcador cuja parte ainda não foi revertida. Combinamos essa parte, mas capturamos o último caractere separadamente. Esse personagem fica na frente e o restante permanece inalterado. O +instrui o Retina a fazer isso repetidamente até que não seja mais possível (porque está no final da string).

i`^(.+)\1$

Finalmente, verificamos se as duas strings são iguais. O ifaz o padrão de maiúsculas e minúsculas - convenientemente, em .NET, isso significa que backreferences também são case-insensitive. Você pode perceber que não temos mais um separador entre a entrada original e a cópia modificada. Porém, não precisamos de um, porque eles têm o mesmo comprimento e, se a string agora consistir exatamente na mesma string duas vezes (conforme o caso), essas devem ser a original e a modificada. Se você está se perguntando o que aconteceu com o feed de linha à direita que usamos como marcador, ele ainda está lá, mas em muitos sabores de expressão regular $também corresponde antes do último caractere da sequência se esse caractere é um avanço de linha.

Como esta etapa consiste apenas em uma única linha, é considerada uma etapa de partida, que conta o número de partidas. Se a entrada for um palíndromo do Atbash, obteremos exatamente uma correspondência e a saída será 1. Caso contrário, esse regex não corresponderá e a saída será 0.

Martin Ender
fonte
Eu acho que é melhor ter feeds de linha como separadores de palco e pilgrows como literal do que vice-versa.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Por conveniência, você também pode inserir feeds de linha por seqüências de escape, \n em regex e $nem substituição, mas isso é um desperdício de bytes para o golfe. ;)
Martin Ender
5

GNU Sed, 105

s/.*/\l&/
h
y/abcdefghijklmnopqrstuvwxyz/zyxwvutsrqponmlkjihgfedcba/
G
:
s/\(.\)\n\1/\n/
t
/^.$/{c1
q}
c0

Saídas 1 para verdade e 0 para falsey.

Tentei fazer isso no Retina, mas não consegui descobrir como salvar a string antes da transliteração Atbash para comparação reversa com after. Talvez haja uma maneira melhor.

O ycomando de transliteração do Sed deixa muito a desejar.

Trauma Digital
fonte
Sim, "guardar" as coisas ainda é complicado na Retina. Você precisaria duplicar a sequência e, em seguida, transliterar e reverter apenas uma cópia. Quero adicionar algum tipo de recurso de ramificação / bifurcação no futuro, mas ainda não tenho certeza dos detalhes.
Martin Ender
Ah, acho que entendi - tentei fazer algo semelhante separando as cordas antes e depois com dois pontos. Eu caí com o regex no final do T- eu estava assumindo que ele era aplicado a cada personagem por sua vez, mas se meu entendimento estiver correto, ele se aplica a todo o espaço do padrão, que é muito mais útil
Digital Trauma
1
O regex em T é aplicado à sequência de entrada. A transliteração é a única executada nas correspondências desse regex e tudo o que é incomparável permanece inalterado. O padrão da regex é [\s\S]+omitindo, você está transliterando tudo.
Martin Ender
Como quiser. :)
Martin Ender
Como é sed GNU, você pode salvar um byte trocando a -rflag pelas barras invertidas em \(e \). Eu concordo com você no ycomando!
precisa saber é o seguinte
4

, 15 caracteres / 30 bytes

ïþ)Ī(ᶐ,ᶐᴙ)ᴙ≔ïþ)

Try it here (Firefox only).

Explicação

ïþ)Ī(ᶐ,ᶐᴙ)ᴙ≔ïþ) // implicit: ï=input, ᶐ=A-Z
ïþ)             // ï.toUpperCase()
   Ī(ᶐ,ᶐᴙ)ᴙ     // transliterate input from A-Z to Z-A, then reverse
           ≔ïþ) // check if that's still equal to ï.toUpperCase()
                // implicit output
Mama Fun Roll
fonte
4

Parênteses, 658 bytes

((()()())(()(((()))))((()()((())))))((()()())(()(((())))()()())((())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))((()()())(()(((())))())((()())((()(((())))()()))((()()()())((()(())(()))(()(((())))()())(()((()))))(()((())))((()((()))())((()(())(())())((()(()))(()(((())))()()())((()(()()))((())()()()()()()()()()()()()()()()()()()()()()()()()())((()(()()))((()(()())())((()((()))(()))(()(((())))()())))(()(((())))()()())))))((()(((())))())((()((()))()())(()(((())))()())))))))((()(())(()))((()()()(()))((()()()()())(()(((()))))))((()(((())))())((()()()()())(()(((())))))))

No momento, só funciona para todas as maiúsculas sem espaço em branco, usando esta versão modificada do script para suportar a leitura de stdin:

#!/usr/bin/env python
from collections import defaultdict
from itertools import izip
import copy
import operator
import os
import sys

# map from paren strings to english names
# for the predefined symbols (lambda, etc)
to_english = defaultdict(lambda:None,\
    {'()': 'lambda',
     '()()': 'define',
     '(())': 'plus',
     '(()())': 'minus',
     '()(())': 'mult',
     '(())()': 'div',
     '()()()': 'if',
     '((()))': 'empty',
     '()()()()': 'charsof',
     '()()(())': 'reverse',
     '()(())()': 'LE',
     '()(()())': 'not',
     '(()())()': 'intofchar',
     '()((()))': 'readline',
     '((()))()': 'cons',
     '(())(())': 'equal',
     '((()))(())': 'car',
     '((()))()()': 'cdr',
     '(())(())()': 'char',
     '(())()(())': 'string'})

# map from english to parenthetic
to_scheme = defaultdict(lambda:None)
for k,v in to_english.iteritems():
    to_scheme[v] = k

def Error(errorString = 'unmatched parens', debug_mode = True):
    if debug_mode:
        print "Error: " + errorString
        sys.exit()
    else:
        raise Exception('paren mismatch')

def bracketsMatch(chars):
    """Returns False if any parentheses in `chars` are not matched
    properly. Returns True otherwise.
    """
    level = 0
    for p in chars:
        if p == '(':
            level += 1
        elif p == ')':
            level -= 1
        if level < 0:
            return False    
    return level == 0

def get_exprs(chars):
    """Returns a list of character sequences such that for each sequence,
    the first and last parenthesis match.
    For example, "(())()()" would be split into ["(())", "()", "()"]
    """
    level = 0
    current = []
    for p in chars:
        if p == '(' or p == ')':
            current.append(p)
        if p == '(':
            level += 1
        elif p == ')':
            level -= 1
        if level == 0:
            yield current
            current = []

## built-in functions ##
def builtin_accumulate(init, accumulate, environment, params):
    """Helper function that handles common logic for builtin functions.
    Given an initial value, and a two-parameter function, the environment, and
    a list of params to reduce, this function will reduce [init] + params using
    the accumulate function and finally returns the resulting value.
    """
    result = init
    for param in params:
        value = interpret(param, environment)
        try: result = accumulate(result, value)
        except: Error(str(value) + ' is not the correct type')
    return result

def builtin_plus(environment, params):
    if len(params) >= 1:
        return builtin_accumulate(interpret(params[0], environment), operator.add, environment, params[1:])
    else:
        return 0.0

def builtin_minus(environment, params):
    if len(params) == 0:
        Error('subtraction requires at least 1 param')
    return builtin_accumulate(interpret(params[0], environment), operator.sub, environment, params[1:])

def builtin_mult(environment, params):
    return builtin_accumulate(1.0, operator.mul, environment, params)

def builtin_div(environment, params):
    if len(params) == 0:
        Error('division requires at least 1 param')
    return builtin_accumulate(interpret(params[0], environment), operator.div, environment, params[1:])

def builtin_LE(environment, params):
    return interpret(params[0], environment) <= interpret(params[1], environment)

def builtin_lambda(environment, params):
    bodies = [body for body in params[1:]]
    params = params[0][1]
    if len(bodies) == 0:
        Error("a function had no body")
    for kind, name in params:
        if kind != 'symbol':
            Error('lambda must have only symbols as arguments')
    def ret(old_environment, arguments):
        #print bodies
        try:
            # create new environment based on args
            environment = copy.copy(old_environment)
            for param, arg in izip(params, arguments):
                environment[param[1]] = interpret(arg, old_environment)
            # evaluate the function bodies using the new environment
            return interpret_trees(bodies, environment, False)
        except:
            Error("Error evaluating a function")
    return ret

def builtin_equal(environment, params):
    for param1, param2 in izip(params[:-1], params[1:]):
        if interpret(param1, environment) != interpret(param2, environment):
            return False
    return True

def builtin_if(environment, params):
    if len(params) != 3:
        Error("'if' takes in exactly 3 params")    
    if interpret(params[0], environment):
        return interpret(params[1], environment)
    return interpret(params[2], environment)

def builtin_not(environment, params):
    return False if interpret(params[0], environment) else True

def builtin_cons(environment, params):
    return (interpret(params[0], environment), interpret(params[1], environment))

def builtin_car(environment, params):
    result = interpret(params[0], environment)
    if not isinstance(result, tuple):
        Error("car must only be called on tuples")
    return result[0]

def builtin_cdr(environment, params):
    result = interpret(params[0], environment)
    if not isinstance(result, tuple):
        Error("cdr must only be called on tuples")
    return result[1]

def builtin_char(environment, params):
    result = interpret(params[0], environment)
    if result != int(result):
        Error("char must only be called on integers")
    return chr(int(result))

def builtin_intofchar(environment, params):
    result = interpret(params[0], environment)
    result = ord(result)
    return result

def builtin_string(environment, params):
    result = ''
    cur = interpret(params[0], environment)
    while cur != ():
        if not isinstance(cur, tuple) or not isinstance(cur[1], tuple):
            Error("string only works on linked lists")
        result += cur[0]
        cur = cur[1]
    return result

def unmakelinked(llist):
    result = ()
    while llist != ():
        if not isinstance(llist, tuple) or not isinstance(llist[1], tuple):
            Error("only works on linked lists")
        result += (llist[0],)
        llist = llist[1]
    return result

def makelinked(tup):
    result = ()
    while tup != ():
        result = (tup[-1],result)
        tup = tup[:-1]
    return result

def builtin_reverse(environment, params):
    result = interpret(params[0], environment)
    result = makelinked(unmakelinked(result)[::-1])
    return result

def builtin_charsof(environment, params):
    result = interpret(params[0], environment)
    result = makelinked(tuple(result))
    return result

def builtin_readline(environment, params):
    result = raw_input()
    return result

# define the default (top-level) scope
default_environment = \
    {to_scheme['plus']: builtin_plus,
     to_scheme['minus']: builtin_minus,
     to_scheme['mult']: builtin_mult,
     to_scheme['div']: builtin_div,
     to_scheme['lambda']: builtin_lambda,
     to_scheme['if']: builtin_if,
     to_scheme['equal']: builtin_equal,
     to_scheme['LE']: builtin_LE,
     to_scheme['not']: builtin_not,
     to_scheme['empty']: (),
     to_scheme['car']: builtin_car,
     to_scheme['cdr']: builtin_cdr,
     to_scheme['cons']: builtin_cons,
     to_scheme['char']: builtin_char,
     to_scheme['string']: builtin_string,
     to_scheme['readline']: builtin_readline,
     to_scheme['charsof']: builtin_charsof,
     to_scheme['reverse']: builtin_reverse,
     to_scheme['intofchar']: builtin_intofchar}

# parse the tokens into an AST
def parse(tokens):
    """Accepts a list of parentheses and returns a list of ASTs.
    Each AST is a pair (type, value).
    If type is 'symbol', value will be the paren sequence corresponding
    to the symbol.
    If type is 'int', value will be a float that is equal to an int.
    If type is expr, value will be a list of ASTs.
    """
    # check for errors
    if not bracketsMatch(tokens):
        Error('paren mismatch')
    # to return - a list of exprs
    exprs = []
    for expr in get_exprs(tokens):
        # check for errors
        if len(expr) < 2:
            Error('too few tokens in: ' + ''.join(expr))
        elif expr[0] != '(' or expr[-1] != ')':
            Error('expression found without () as wrapper')
        # pop off starting and ending ()s
        expr = expr[1:-1]
        # symbol
        if expr[:2] == ['(', ')'] and len(expr) > 2:
            exprs.append(('symbol', ''.join(expr[2:])))
        # integer
        elif expr[:4] == ['(', '(', ')', ')'] and len(expr) >= 4:
            exprs.append(('num', expr[4:].count('(')))
        # expr
        else:
            exprs.append(('expr', parse(expr)))
    return exprs

def interpret(tree, environment):
    """Interpret a single tree (may not be a define) and return the result"""
    kind, value = tree
    if kind == 'num':
        return float(value)
    elif kind == 'symbol':
        if value in environment:
            return environment[value]
        else:
            Error('Unresolved symbol - ' + value)
    elif kind == 'expr':
        function = interpret(value[0], environment)
        if not hasattr(function, '__call__'):
            Error('Symbol "'+value[0]+'" is not a function.')
        return function(environment, value[1:])
    else:
        Error("Unknown tree kind")

def interpret_trees(trees, environment, doprint = True):
    """Interpret a sequence of trees (may contain defines)
    and output the result.
    The trees passed in should be ASTs as returned by parse().
    If doprint is true, the post-interpretation value of each tree is printed.
    """
    environment = copy.copy(environment)
    # hoist define statements (note: trees.sort is stable)
    #trees.sort(key = lambda x: 0 if x[0] == 'expr' and x[1][0][1] == to_scheme['define'] else 1)
    ret = None
    for tree in trees:
        if tree[0] == 'expr' and tree[1][0][0] == 'symbol' and tree[1][0][1] == to_scheme['define']:
            try:
                symbol = tree[1][1]
                if symbol[0] != 'symbol':
                    Error('first argument to define must be a symbol')
                symbol = symbol[1]
                value = tree[1][2]
                environment[symbol] = interpret(value, environment)
            except:
                Error('error evaluating define statement')
        else:
            ret = interpret(tree, environment)
            if doprint:
                print ret,
    return ret

# read in the code ignoring all characters but '(' and ')' 
f = open(sys.argv[1],'r')
code = []
for line in f.readlines():
    code += [c for c in line if c in '()']

# parse and interpret the code. print 'Parenthesis Mismatch'
# if an error occured.
#try:
syntax_trees = parse(code)
interpret_trees(syntax_trees, default_environment)
#except:
#    print 'Parenthesis Mismatch'

Explicação

(
  define
  (() ()())
  input [[[[]]]]
  (() (((()))))
  exec readline
  ( (() ()((()))) )
)
(
  define
  (() ()())
  value of 'A' [[[[]]]] [][][]
  (() (((())))()()())
  65
  ((()) ()()()()()()()()()()
        ()()()()()()()()()()
        ()()()()()()()()()()
        ()()()()()()()()()()
        ()()()()()()()()()()
        ()()()()()()()()()()
        ()()()()())
)
(
  define
  (() ()())
  atbash [[[[]]]] []
  (() (((())))())
  (
    lambda
    (() ())
    (
      list [[[[]]]] [][]
      (() (((())))()())
    )
    (
      if
      (() ()()())
      (
        equal
        (() (())(()))
        list
        (() (((())))()())
        empty
        (() ((())))
      )
      then return empty
      (() ((())))
      else
      (
        cons
        (() ((()))())
        (
          char
          (() (())(())())
          (
            plus
            (() (()))
            value of 'A' 65
            (() (((())))()()())
            (
              minus
              (() (()()))
              25
              ((()) ()()()()()()()()()()
                    ()()()()()()()()()()
                    ()()()()())
              (
                minus
                (() (()()))
                (
                  intofchar
                  (() (()())())
                  (
                    car
                    (() ((()))(()))
                    list
                    (() (((())))()())
                  )
                )
                value of 'A' 65
                (() (((())))()()())
              )
            )
          )
        )
        (
          atbash
          (() (((())))())
          (
            cdr
            (() ((()))()())
            list
            (() (((())))()())
          )
        )
      )
    )
  )
)

(
  equals
  (() (())(()))
  (
    reverse
    (() ()()(()))
    (
      charsof
      (() ()()()())
      input
      (() (((()))))
    )
  )
  (
    atbash
    (() (((())))())
    (
      charsof
      (() ()()()())
      input
      (() (((()))))
    )
  )
)
Harry
fonte
4
Deseja que o seu código seja o mais longo? : P
Zorgatone 07/01
4

Python 3, 90 85 bytes

s=input().upper()
print(s[::-1]==''.join(chr([o,155-o][64<o<91])for o in map(ord,s)))

Convertemos a entrada em maiúscula e, em seguida, calculamos a sequência Atbashed subtraindo todos os ordinais de 155 se estiverem no intervalo do alfabeto em maiúsculas.

lirtosiast
fonte
4

Kerf , 73 bytes

Kerf é uma linguagem proprietária na mesma família geral que APL, J e K. É possível escrever oneliners crípticos e compactos e evitar o uso de loops explícitos:

{[s]s:_ s;n:?isnull i:s search\<a:char 97+^26;f:(/a)[i];s match/f[n]:s[n]}

No entanto, o uso dos aliases explicitados para comandos em vez dos símbolos abreviados e o uso de identificadores significativos tornam o programa muito mais claro e fácil de seguir, mesmo que você não esteja familiarizado com o Kerf:

def atbash_palindrome(str) {
  str:       tolower str
  alpha:     char range(97, 123)
  indices:   str search mapleft alpha
  encoded:   (reverse alpha)[indices]
  notfound:  which isnull indices
  return     str match reverse encoded[notfound]:str[notfound]
}

Em ação:

KeRF> p: {[s]s:_ s;n:?isnull i:s search\<a:char 97+^26;f:(/a)[i];s match/f[n]:s[n]};

KeRF> p mapdown ["WIZARD","Wizard","W I Z A R D","ABCXYZ","345 09%","ev","Zyba","$%%$","-AZ"]
  [1, 1, 1, 1, 0, 1, 1, 1, 0]

O Kerf provavelmente não vai ganhar uma tonelada de competições de codegolfe, especialmente contra linguagens criadas para fins específicos, mas pode valer a pena mexer se você gosta da idéia de linguagens da família APL, mas acha a sintaxe muito estranha. ( Isenção de responsabilidade: sou o autor do manual de referência do Kerf. )

JohnE
fonte
3

Prolog, 121 bytes

a(W):-upcase_atom(W,X),atom_codes(X,C),b(C,Z),!,reverse(Z,C).
b([A|T],[R|S]):-(A>64,A<91,R is 77-A+78;R=A),(b(T,S);S=[]).

Isso é chamado com um átomo como entrada, por exemplo a('WIZARD')..

Fatalizar
fonte
3

JavaScript (ES6), 91

x=>(x=[...x.toLowerCase()]).every(c=>((v=parseInt(c,36))>9?(45-v).toString(36):c)==x.pop())

TESTE

F=x=>(x=[...x.toLowerCase()]).every(c=>((v=parseInt(c,36))>9?(45-v).toString(36):c)==x.pop())

console.log=x=>O.textContent+=x+'\n'

;[
 ["WIZARD", true]
,["Wizard", true] // case doesn't matter
,["wIzArD", true]
,["W I Z A R D", true]
,["W IZ ARD", false] // the atbash of this is D RA ZIW, which is not a palindrome of W IZ ARD
,["ABCXYZ", true] // ZYXCBA
,["345 09%", false] // is not a palindrome
,["ev", true] // ve
,["AZGDFSSF IJHSDFIU HFIA", false]
,["Zyba", true]
,["-AZ", false] // -ZA is not a reverse of -AZ
,["Tree vvig", true] // Givv eert 
,["$%%$", true] // palindrome
,["$%ZA%$", true]
].forEach(t=>{var i=t[0],x=t[1],r=F(i);
              console.log(i+' -> '+r+(x==r?' OK':' Fail (expected:'+x+')'))})
<pre id=O></pre>
Expandir snippet

edc65
fonte
3

C, 101 97 bytes

Como a pergunta especificou caracteres ASCII, isso não lida com nenhuma outra codificação. 

f(char*s){char*p=s+strlen(s);while(*s&&!(isalpha(*--p)?*s<64||*s+*p-27&31:*s-*p))++s;return s>p;}

Explicação

int f(char*s)
{
    char *p = s + strlen(s);
    while (*s && !(isalpha(*--p) ? *s<64||*s+*p-27&31 : *s-*p))
        ++s;
    return s > p;
}

Fazemos um ponteiro pque começa no final da string. Em seguida, fazemos um loop, movendo-nos se pum para o outros chega ao fim. Isso significa que todos os pares de caracteres serão verificados duas vezes, mas isso economiza alguns bytes em comparação à parada assim que os ponteiros passam.

A cada iteração, verificamos se *pé uma letra. Se assim for, verifique se *sestá na faixa de letras (ASCII 64 para cima), e que *pe *sadicionar até 27 (mod 32). As letras que não sejam letras com mais de 64 anos serão reprovadas nesse teste, portanto, não precisamos verificar isalpha(*s).

Se *pnão é uma letra, simplesmente testamos se é igual a *s. Nos dois casos, encerramos o loop antes se patravessamos.

Se se ptivermos cruzado, todos os pares de letras corresponderam corretamente; portanto, retornamos verdadeiro; caso contrário, retornamos falso.

Programa de teste

Passe as seqüências a serem testadas como argumentos da linha de comando. Isso produz uma saída correta para todos os casos de teste. Não há requisito fornecido para a cadeia vazia; minha implementação retorna false para essa entrada.

#include <stdio.h>

int main(int argc, char **argv)
{
    while (*++argv)
        printf("\"%s\" => %s\n", *argv, f(*argv)?"true":"false");
    return 0;
}
Toby Speight
fonte
você pode soltar f's declaração de tipo para um protótipo de estilo K & R:f(char*s)
cat
3

Perl 5, 70 bytes

Uma sub-rotina:

{$"='';reverse(map/[A-Z]/?chr(155-ord):$_,(@_=split'',uc$_[0]))eq"@_"}

Veja em uso:

print sub{...}->("W i z a r d")
msh210
fonte
2

MATL, 23 bytes

Usa a versão atual .

jkt"@@2Y2m?_219+]h]tP=A

Exemplos

>> matl
 > jkt"@@2Y2m?_219+]h]tP=A
 > 
> Tree vvig
1

>> matl
 > jkt"@@2Y2m?_219+]h]tP=A
 > 
> W IZ ARD
0
Luis Mendo
fonte
2

CJam, 18 bytes

qeu_'[,65>_W%erW%=

Experimente online

Funciona convertendo a entrada para maiúscula, executando a tradução de letras, vira a seqüência e verifica a igualdade.

GamrCorps
fonte
2

Japonês, 30 27 bytes

U=Uv)w ¥Ur"[a-z]"_c +4^31 d

Experimente online!

Como funciona

Isso se baseia em grande parte na minha resposta japonesa em Trocar o alfabeto.

U=Uv)w ¥Ur"[a-z]"_c +4^31 d
U=Uv)      // Set U to U.toLowerCase().
w ¥        // Reverse it, and check if it is equal to:
Ur"[a-z]"  //  Take the input and replace each letter with:
 _c +4     //   Take its char code and add 4. This results in
           //   the string      "abc...xyz"
           //   becoming        "efg...|}~".
 ^31       //   XOR the result by 31. This flips its last five 5 bits.
           //   We now have     "zyx...cba".
 d         //   Convert back from a char code.
           // Implicit: output last expression
ETHproductions
fonte
1

Python, 156 112 bytes

a=map(chr,range(65,91))
s=raw_input().upper()
print ''.join([dict(zip(a,a[::-1])).get(i,i) for i in s])==s[::-1]

Basicamente, ele faz um dicionário da tradução com letras maiúsculas e a entrada é maiúscula (se tudo fosse minúsculo, isso acrescentaria 5 bytes). Em seguida, para cada caractere na entrada em maiúscula, faça a tradução e anexe a uma lista, a menos que o caractere não esteja no alfabeto; nesse caso, anexe o caractere como está. Junte-se à lista inteira e compare com a lista invertida.

Grite para o @Artyer por postar quase exatamente como eu ia postar antes de mim. Mas preciso confirmar, esse é o meu trabalho e fiz isso de forma independente .

Baseado na resposta de Julia por Alex A. Experimente aqui

TanMath
fonte
Há um espaço em branco desnecessário depois .get(i,i). +1.
Yytsi 9/08/16
1

05AB1E , 8 bytes (não concorrente)

Esse idioma usa recursos que pós-datam o desafio e, portanto, não são concorrentes.

Código:

lDAAR‡RQ

Explicação:

l         # Lowercase the implicit input
 D        # Duplicate top of the stack
  AAR     # Push the lowercase alphabet (A) and the lowercase alphabet reversed (AR)
     ‡    # Transliterate a -> b
      R   # Reverse this string
       Q  # Compare with the input string

Experimente online!

Adnan
fonte
1

Fator, 118 113 bytes

Esta é uma função anônima.

[ >upper dup >array [ 1string 65 90 [a,b] [ 1string ] map dup reverse zip >hashtable at ] map "" join reverse = ]

Não conheço uma maneira mais curta de gerar uma matriz associativa do alfabeto: c

gato
fonte
1

Clojure, 100 bytes

(defn x[b](let[a(.toUpperCase b)c(reverse a)](=(map #(char(if(<= 65(int %)90)(- 155(int %))%))a)c)))

Deveria ser possível reduzi-lo a uma única função anônima, cortando em torno de mais 10 bytes (de declarações), mas ainda não encontrei um caminho.

Michael M
fonte
1

Ruby, 79 77 bytes

s=$*[0].upcase
exit(s==s.reverse.tr('A-Z','ZYXWVUTSRQPONMLKJIHGFEDCBA'))?0:1

Aceita a palavra para testar como um argumento da linha de comandos. Sai com o código 0 (que é verdadeiro para o shell) se o argumento for um auto-palíndromo atbash ou com o código 1 caso contrário.

PellMell
fonte
1
O putsresultado não seria mais curto do que sair com um ternário?
cat
FYI $*é um apelido para ARGV.
Jordânia
1

Ruby, 56 bytes

->s{s.upcase!;s==s.tr(x=[*?A..?Z]*'',x.reverse).reverse}

É uma função anônima que pega uma string e retorna trueou false. É um pouco desajeitado: para salvar alguns bytes, ele usa a variante destrutiva de upcase(com um! depois). upcase!infelizmente retorna nilse nada for alterado (como todas as entradas numéricas), então alguns bytes são perdidos tentando lidar com isso. Ainda funciona tho :)

daniero
fonte
1

MATLAB, 61 bytes

Não é a solução mais curta, mas ainda é interessante

f=@(a)~any(changem(upper(a),90:-1:65,65:90)-fliplr(upper(a)))
PieCot
fonte