Atbash Self Palindromes

27

Considérez la transformation 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

Où A ⇔ Z et L ⇔ O, par exemple Il y a une propriété intéressante que certains mots partagent. Lorsque certaines chaînes sont traduites en leur équivalent atbash, cette traduction est le mot d'origine inversé. J'appelle ces Self Palindromes Atbash .

Par exemple, traduisons WIZARD :

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

Le résultat est DRAZIW , qui est inversé par WIZARD . Ainsi, WIZARD est un auto-palindrome atbash.

Objectif Étant donné une chaîne de caractères ASCII imprimables, sortir ou renvoyer une valeur véridique si cette chaîne est un auto-palindrome atbash, et une valeur falsey sinon. (Cela se fait via STDIN, équivalent le plus proche, entrée fonctionnelle, etc. Si votre langue ne peut pas faire cela, envisagez de choisir une langue différente, vous pouvez coder en dur l'entrée.) Vous devez le faire sans tenir compte de la casse. Si l'entrée est un palindrome et n'est pas affectée par la séquence atbash, vous devez toujours afficher true, car un palindrome + lui-même est un palindrome. Il s'agit d'un code-golf , donc le programme le plus court en octets l'emporte.

Cas de test

"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

Classement

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) en tant que liste des solutions les plus courtes par langue et b) en tant que classement général.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Afficher l'extrait de code

code-golf string cryptography palindrome Conor O'Brien
la source
Connexes: échangez l'alphabet .
nicael
4
AtBash n'est en fait pas nouveau. C'est la transformation de la lettre hébraïque Kabala (Mysticisme juif) équivalente à cela. Étant donné que l'hébreu est écrit uniquement avec des wovels, toute chaîne de lettres peut être lue en insérant des wovels aléatoires. ATB (a) SH est un mnémonique pour transformer Alef (première lettre hébraïque) en Tav (dernier), Beis (deuxième) en SHin (avant-dernier).
Adám
1
Pensez à donner -1000000 points si le code de solution de quelqu'un est lui-même un auto-palindrome atbash? : p
kojiro
3
@kojiro Non trivial par opposition à code {Comment-symbol}{Atbash'ed Comment-symbol} Atbash'ed code...
Adám
1
@ mbomb007 J'ai dit que je pourrais offrir une prime si un tel programme non trivial était trouvé
Conor O'Brien

Réponses:

8

RX , 9 8 octets

Fortement inspiré par Retina, je l'ai fait il y a quelques jours. Code:

prR`w$rM

Explication:

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.

Essayez-le ici !

Adnan
la source
Alors, comment fonctionne la langue elle-même? S'agit-il d'une sorte de langage de traitement de chaînes basé sur la pile? C'est vraiment impressionnant, mais pour autant que je sache, il n'y a pas encore de moyen de boucler dans le langage, ce qui signifie qu'il est très peu probable que cela réponde à nos normes de langage de programmation à ce stade.
Martin Ender
@ MartinBüttner Ce langage est principalement basé sur le traitement de l'entrée à l'aide d'un modèle de pile. Il n'utilise pas d'entiers (et ne le fera probablement jamais). J'ai mis en place une boucle, mais cette version n'est pas encore sortie.
Adnan
@Martin Regexes sont capables de tester la primalité par eux-mêmes, donc je suis presque sûr que c'est valide.
lirtosiast
@ThomasKwa Pour autant que je puisse voir, l'interpréteur n'utilise aucune expression régulière réelle.
Martin Ender
@Martin Hmm, vous avez raison.
lirtosiast
11

Pyth, 10 9 octets

qJrz0_XJG

Essayez ce violon en ligne ou vérifiez tous les cas de test à la fois.

Explication

qJrz0_XJG
  rz0      Lowercase input
 J         Store a copy in J
     _XJG  Translate J with the reverse alphabet and reverse
q          Compare
un spaghetto
la source
3
Puisque vous utilisez rz0deux fois, n'est-il pas plus court de l'enregistrer dans une variable?
xnor
1
Comme @xnor le suggère, q_Jrz0XJGest un octet plus court.
PurkkaKoodari
6

Julia, 96 octets

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

Il s'agit d'une fonction lambda qui accepte une chaîne et renvoie une chaîne. Pour l'appeler, affectez-le à une variable.

Non golfé:

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.
la source
5

Utilitaires Bash + Linux, 56

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

Génère la chaîne vide pour Truthy et quelque chose comme - /dev/fd/63 differ: byte 1, line 1pour Falsey. Si cela n'est pas acceptable, nous pouvons ajouter -spour 3 octets supplémentaires et utiliser les codes de retour Unix standard de 0 pour succès (Truthy) et 1 pour échec (Falsey).

Traumatisme numérique
la source
5

Rétine , 44 octets

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

Imprime 1ou 0. Le nombre d'octets suppose que le fichier est codé en ISO 8859-1.

Essayez-le en ligne!

Cette réponse a été largement inspirée par la réponse sed de DigitalTrauma mais là encore, je suppose qu'il n'y a pas beaucoup d'approches à ce défi en premier lieu.

Explication

Chaque fois que vous voyez un , la première chose que Retina fait après avoir divisé le code en lignes est de remplacer tous ces pilcrows par des sauts de ligne. Cela permet l'inclusion de sauts de ligne pour un seul octet même si les sauts de ligne sont le séparateur d'étape de Retina.

$
¶$_

Nous commençons par dupliquer l'entrée. Nous faisons correspondre la fin de l'entrée avec $et insérons un saut de ligne avec l'entrée elle-même (en utilisant $_).

T`lL`Ro`.+$

Une étape de translittération. Commençons par l'expression rationnelle: .+$. Il correspond à la deuxième copie de l'entrée (en s'assurant que la correspondance va jusqu'à la fin de la chaîne). Ainsi, seuls les caractères de la deuxième copie seront translittérés. La translittération elle-même utilise certaines fonctionnalités très récentes. let Lsont des classes de caractères pour les lettres minuscules et majuscules, respectivement. ofait référence à l'autre jeu de caractères de la translittération et l' Rinverse. Les deux jeux de caractères s'étendent donc à:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba

Vous remarquerez que cela permute le cas tout en faisant le chiffrement Atbash, mais nous ferons quand même la comparaison finale sans tenir compte de la casse.

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

Maintenant, nous inversons la deuxième copie. Malheureusement, Retina n'a pas encore de moyen pratique de le faire, nous devrons donc déplacer un personnage de la fin vers l'avant. Pour ce faire, vous devez réaffecter le séparateur de saut de ligne comme marqueur dont la partie n'a pas encore été inversée. Nous faisons correspondre cette partie mais capturons le dernier caractère séparément. Ce personnage passe devant et le reste est inchangé. Le +dit à Retina de le faire à plusieurs reprises jusqu'à ce que ce ne soit plus possible (parce que c'est à la fin de la chaîne).

i`^(.+)\1$

Enfin, nous vérifions si les deux chaînes sont identiques. Le irend le modèle insensible à la casse - commodément, dans .NET, cela signifie que les références arrières sont également insensibles à la casse. Vous remarquerez peut-être que nous n'avons plus de séparateur entre l'entrée d'origine et la copie modifiée. Nous n'en avons pas besoin cependant, car ils ont la même longueur, et si la chaîne se compose maintenant exactement de la même chaîne deux fois (jusqu'au cas), alors il doit s'agir de la chaîne d'origine et de la chaîne modifiée. Si vous vous demandez ce qui est arrivé au saut de ligne arrière que nous avons utilisé comme marqueur, il est toujours là, mais dans de nombreuses saveurs d'expression régulière, $il correspond également avant le dernier caractère de la chaîne si ce caractère est un saut de ligne.

Étant donné que cette étape ne se compose que d'une seule ligne, elle est considérée comme une étape de match, qui compte le nombre de matchs. Si l'entrée est un palindrome Atbash, nous obtiendrons exactement une correspondance et la sortie est 1. Sinon, cette expression régulière ne correspondra pas et la sortie sera 0.

Martin Ender
la source
Je suppose qu'il vaut mieux que les sauts de ligne soient les séparateurs de scène et les pilcrows le littéral plutôt que l'inverse.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Pour plus de commodité, vous pouvez également insérer des sauts de ligne par séquences d'échappement, \n en regex et $nen substitution, mais ce sont des octets gaspillés pour le golf. ;)
Martin Ender
5

GNU Sed, 105

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

Sorties 1 pour vérité et 0 pour falsey.

J'ai essayé de le faire dans Retina, mais je n'ai pas pu trouver comment enregistrer la chaîne avant la translittération Atbash pour une comparaison inverse avec l'after. Il y a peut-être une meilleure façon.

La ycommande de translittération de Sed laisse beaucoup à désirer.

Traumatisme numérique
la source
Ouais, "stocker" des choses est toujours lourd à Retina. Vous devez dupliquer la chaîne, puis translittérer et inverser une seule copie. Je veux ajouter une sorte de fonctionnalité de branchement / fourche à l'avenir, mais je ne suis pas encore sûr des détails.
Martin Ender
Ah, je pense que je vois - j'ai essayé de faire quelque chose de similaire en séparant les cordes avant et après avec deux points. Je suis tombé avec le regex à la fin du T- je supposais qu'il s'appliquait à chaque personnage tour à tour, mais si ma compréhension est bonne, il s'applique à l'ensemble de l'espace de modèle, ce qui est beaucoup plus utile
Digital Trauma
1
L'expression régulière en T est appliquée à la chaîne d'entrée. La translittération est la seule effectuée dans les correspondances de cette expression régulière et tout ce qui n'a pas de correspondance reste inchangé. Le regex par défaut est [\s\S]+donc en l'omettant, vous translittérez tout.
Martin Ender
Comme vous le souhaitez. :)
Martin Ender
Comme c'est GNU sed, vous pouvez enregistrer un octet en échangeant le -rdrapeau pour les contre-obliques dans \(et \). Je suis d'accord avec toi sur la ycommande!
Toby Speight
4

𝔼𝕊𝕄𝕚𝕟, 15 caractères / 30 octets

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

Try it here (Firefox only).

Explication

ïþ)Ī(ᶐ,ᶐᴙ)ᴙ≔ïþ) // 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
la source
4

Parenthétique, 658 octets

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

Fonctionne uniquement pour toutes les majuscules sans espace pour le moment, en utilisant cette version modifiée du script pour qu'il prenne en charge la lecture depuis 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'

Explication

(
  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
la source
4
Voulez-vous que votre code soit le plus long? : P
Zorgatone
4

Python 3, 90 85 octets

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

Nous convertissons l'entrée en majuscules, puis calculons la chaîne Atbashed en soustrayant toutes les ordinales de 155 si elles sont dans la plage alphabétique majuscule.

lirtosiast
la source
4

Kerf , 73 octets

Kerf est un langage propriétaire de la même famille générale que APL, J et K. Il est possible d'écrire des oneliners cryptiques et compacts et d'éviter l'utilisation de boucles explicites:

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

Cependant, l'utilisation des alias épelés pour les commandes au lieu des symboles abrégés et l'utilisation d'identificateurs significatifs rendent le programme beaucoup plus clair et assez facile à suivre même si vous n'êtes pas familier avec 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]
}

En action:

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]

Kerf ne va probablement pas gagner une tonne de compétitions de codegolf, en particulier contre les langages conçus à cet effet, mais cela pourrait valoir la peine d'être modifié si vous aimez l'idée des langages de la famille APL mais trouvez la syntaxe trop bizarre. ( Avertissement: je suis l'auteur du manuel de référence pour Kerf. )

JohnE
la source
3

Prolog, 121 octets

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=[]).

Ceci est appelé avec un atome en entrée, par exemple a('WIZARD')..

Fatalize
la source
3

JavaScript (ES6), 91

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

TESTER

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>
Développer l'extrait

edc65
la source
3

C, 101 97 octets

Comme la question spécifiait des caractères ASCII, cela ne gère aucun autre encodage. 

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

Explication

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;
}

Nous créons un pointeur pqui commence à la fin de la chaîne. Nous bouclons ensuite, nous déplaçant tous les deux set l'un pvers l'autre sjusqu'à la fin. Cela signifie que chaque paire de caractères sera vérifiée deux fois, mais cela économise quelques octets par rapport à l'arrêt dès que les pointeurs se croisent.

À chaque itération, nous vérifions s'il *ps'agit d'une lettre. Si c'est le cas, vérifiez que *sc'est dans la plage de lettres (ASCII 64 vers le haut), et que *pet *sajoutez jusqu'à 27 (mod 32). Les non-lettres supérieures à 64 échoueront à ce test, nous n'avons donc pas besoin de vérifier isalpha(*s).

S'il *pne s'agit pas d'une lettre, nous testons simplement si elle est égale à *s. Dans les deux cas, nous terminons la boucle avant set ptraversons.

Si set pont traversé, alors chaque paire de lettres correspondait correctement, donc nous retournons vrai; sinon nous retournons faux.

Programme de test

Passez les chaînes à tester comme arguments de ligne de commande. Cela produit une sortie correcte pour tous les cas de test. Il n'y a aucune exigence fournie pour la chaîne vide; mon implémentation renvoie false pour cette entrée.

#include <stdio.h>

int main(int argc, char **argv)
{
    while (*++argv)
        printf("\"%s\" => %s\n", *argv, f(*argv)?"true":"false");
    return 0;
}
Toby Speight
la source
vous pouvez supprimer fla déclaration de type pour un prototype de style K&R:f(char*s)
cat
3

Perl 5, 70 octets

Un sous-programme:

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

Voyez-le en cours d'utilisation:

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

MATL, 23 octets

Utilise la version actuelle .

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

Exemples

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

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

CJam, 18 octets

qeu_'[,65>_W%erW%=

Essayez-le en ligne

Fonctionne en convertissant les entrées en majuscules, en effectuant la traduction des lettres, en retournant la chaîne et en vérifiant l'égalité.

GamrCorps
la source
2

Japt, 30 27 octets

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

Essayez-le en ligne!

Comment ça marche

Ceci est basé en grande partie sur ma réponse Japt sur Swap the Alphabet.

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
la source
1

Python, 156 112 octets

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]

Fondamentalement, il fait un dictionnaire de la traduction avec des lettres majuscules et l'entrée est en majuscule (si tout était en minuscule à la place, cela ajouterait 5 octets). Ensuite, pour chaque caractère de l'entrée en majuscule, effectuez la traduction et ajoutez-le à une liste à moins que le caractère ne soit pas dans l'alphabet, auquel cas ajoutez le caractère tel quel. Rejoignez la liste entière et comparez-la à la liste inversée.

Merci à @Artyer pour avoir posté presque exactement comme j'allais poster avant moi. Mais je dois confirmer, c'est mon travail et je l'ai fait indépendamment .

Basé sur la réponse de Julia par Alex A. Essayez-le ici

TanMath
la source
Il y a un espace blanc inutile après .get(i,i). +1.
Yytsi
1

05AB1E , 8 octets (non concurrents)

Ce langage utilise des fonctionnalités postérieures au défi et n'est donc pas concurrentiel.

Code:

lDAAR‡RQ

Explication:

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

Essayez-le en ligne!

Adnan
la source
1

Facteur, 118113 octets

Il s'agit d'une fonction anonyme.

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

Je ne connais pas de moyen plus court pour générer un tableau associatif de l'alphabet: c

chat
la source
1

Clojure, 100 octets

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

Il devrait être possible de le réduire à une seule fonction anonyme, coupant environ 10 octets de plus (de déclarations) mais je n'ai pas encore trouvé de moyen.

Michael M
la source
1

Rubis, 79 77 octets

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

Accepte le mot à tester comme argument de ligne de commande. Quitte avec le code 0 (qui est véridique pour le shell) si l'argument est un auto palindrome atbash, ou avec le code 1 sinon.

PellMell
la source
1
Le putsrésultat ne serait-il pas plus court que de sortir avec un ternaire?
chat
FYI $*est un alias pour ARGV.
Jordan
1

Rubis, 56 octets

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

C'est une fonction anonyme qui prend une chaîne et retourne trueou false. C'est plutôt maladroit: pour économiser quelques octets, il utilise la variante destructrice de upcase(avec un !après). upcase!renvoie malheureusement nilsi rien n'est changé (comme toutes les entrées numériques), donc certains octets sont perdus en essayant de gérer cela. Fonctionne toujours tho :)

daniero
la source
1

MATLAB, 61 octets

Pas la solution la plus courte, mais toujours intéressante

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