Atbash Self Palindromes

27

Betrachten Sie die Atbash-Transformation :

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

Wo A ⇔ Z und L ⇔ O, zB gibt es eine interessante Eigenschaft, die einige Wörter teilen. Wenn einige Zeichenfolgen in ihr atbash-Äquivalent übersetzt werden, ist die Übersetzung das umgekehrte Originalwort. Ich nenne diese Atbash Self Palindromes .

Lassen Sie uns als Beispiel WIZARD übersetzen :

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

Das Ergebnis ist DRAZIW ( WIZARD) . Somit ist WIZARD ein Atbash-Selbst-Palindrom.

Ziel Wenn eine Zeichenfolge mit druckbaren ASCII-Zeichen angegeben wird, wird ein wahrer Wert ausgegeben oder zurückgegeben, wenn die Zeichenfolge ein atbash-Selbst-Palindrom und andernfalls ein falscher Wert ist. (Dies erfolgt über STDIN, das nächstgelegene Äquivalent, eine funktionale Eingabe usw. Wenn Ihre Sprache keine dieser Eingaben ausführen kann, ziehen Sie in Betracht, eine andere Sprache auszuwählen, in der Sie die Eingabe möglicherweise fest codieren.) Dies sollte unabhängig von Groß- und Kleinschreibung erfolgen. Wenn die Eingabe ein Palindrom ist und von der Atbash-Sequenz nicht betroffen ist, sollten Sie trotzdem true ausgeben, da ein Palindrom + selbst ein Palindrom ist. Dies ist ein Code-Golf , also gewinnt das kürzeste Programm in Bytes.

Testfälle

"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

Bestenliste

Das Stapel-Snippet am Ende dieses Beitrags generiert den Katalog aus den Antworten a) als Liste der kürzesten Lösungen pro Sprache und b) als Gesamt-Bestenliste.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Snippet angezeigt wird:

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

Code-Snippet anzeigen

code-golf string cryptography palindrome Conor O'Brien
quelle
Verwandte: Tauschen Sie das Alphabet .
Nicoleel
4
AtBash ist eigentlich nichts Neues. Dies entspricht der hebräischen Buchstabenumwandlung der Kabala (Jüdische Mystik). Da Hebräisch nur mit Wovels geschrieben wird, kann jede Buchstabenfolge durch Einfügen zufälliger Wovels gelesen werden. ATB (a) SH ist eine Abkürzung für die Umwandlung von Alef (erster hebräischer Buchstabe) in Tav (letzter), Beis (zweiter) in SHin (vorletzter).
Adám
1
Erwägen Sie, -1000000 Punkte zu vergeben, wenn jemandes Lösungscode selbst ein atbash-Selbst-Palindrom ist? : p
kojiro
3
@ Kojiro Nicht trivial im Gegensatz zu code {Comment-symbol}{Atbash'ed Comment-symbol} Atbash'ed code...
Adám
1
@ mbomb007 Ich sagte, ich könnte ein Kopfgeld anbieten, wenn solch ein nicht triviales Programm gefunden wird
Conor O'Brien

Antworten:

8

RX , 9 8 Bytes

Stark von Retina inspiriert, habe ich das vor einigen Tagen gemacht. Code:

prR`w$rM

Erläuterung:

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.

Probieren Sie es hier aus !

Adnan
quelle
Wie funktioniert also die Sprache selbst? Handelt es sich um eine Art stapelbasierte Zeichenfolgenverarbeitungssprache? Das ist wirklich beeindruckend, aber soweit ich das beurteilen kann, gibt es noch keine Möglichkeit, eine Schleife in der Sprache zu erstellen, was bedeutet, dass es sehr unwahrscheinlich ist, dass dies unseren Standards einer Programmiersprache in dieser Phase entspricht.
Martin Ender
@ MartinBüttner Diese Sprache basiert hauptsächlich auf der Verarbeitung der Eingabe mit einem Stack-Modell. Ganzzahlen werden nicht verwendet (und werden es wahrscheinlich auch nie tun). Ich habe eine Schleife implementiert, aber diese Version wurde noch nicht veröffentlicht.
Adnan
@Martin Regexes sind in der Lage, Primalitätstests selbst durchzuführen, daher bin ich mir ziemlich sicher, dass dies gültig ist.
Lirtosiast
@ThomasKwa Soweit ich sehen kann, verwendet der Interpreter keine regulären Ausdrücke.
Martin Ender
@ Martin Hmm, du hast recht.
Lirtosiast
11

Pyth, 10 9 Bytes

qJrz0_XJG

Probieren Sie diese Geige online aus oder überprüfen Sie alle Testfälle auf einmal.

Erläuterung

qJrz0_XJG
  rz0      Lowercase input
 J         Store a copy in J
     _XJG  Translate J with the reverse alphabet and reverse
q          Compare
ein Spaghetto
quelle
3
Ist rz0es nicht kürzer, es in einer Variablen zu speichern, da Sie es zweimal verwenden?
Xnor
1
Wie @xnor vorschlägt, q_Jrz0XJGist ein Byte kürzer.
PurkkaKoodari
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)

Dies ist eine Lambda-Funktion, die eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

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.
quelle
5

Bash + Linux-Utils, 56

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

Gibt den leeren String für Truthy und so etwas wie - /dev/fd/63 differ: byte 1, line 1für Falsey aus. Wenn dies nicht akzeptabel ist, können wir -s3 zusätzliche Bytes hinzufügen und die Standard-Unix-Rückkehrcodes 0 für Erfolg (Wahrheit) und 1 für Fehler (Falsch) verwenden.

Digitales Trauma
quelle
5

Retina , 44 Bytes

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

Druckt 1oder 0. Die Byteanzahl setzt voraus, dass die Datei gemäß ISO 8859-1 codiert ist.

Probieren Sie es online!

Diese Antwort wurde größtenteils von der sed-Antwort von DigitalTrauma inspiriert , aber ich denke, es gibt zunächst nicht so viele Ansätze für diese Herausforderung.

Erläuterung

Wann immer Sie ein sehen , besteht das erste, was Retina nach dem Aufteilen des Codes in Zeilen tut, darin, alle diese Pilcrows durch Zeilenvorschübe zu ersetzen. Dies ermöglicht die Einbeziehung von Zeilenvorschüben für ein einzelnes Byte, obwohl Zeilenvorschübe das Phasentrennzeichen von Retina sind.

$
¶$_

Wir beginnen mit dem Duplizieren der Eingabe. Wir stimmen das Ende der Eingabe mit ab $und fügen einen Zeilenvorschub zusammen mit der Eingabe selbst ein (using $_).

T`lL`Ro`.+$

Eine Transliterationsphase. Beginnen wir mit dem regulären Ausdruck starten: .+$. Es stimmt mit der zweiten Kopie der Eingabe überein (indem sichergestellt wird, dass die Übereinstimmung bis zum Ende der Zeichenfolge reicht). Daher werden nur die Zeichen in der zweiten Kopie transliteriert. Die Transliteration selbst nutzt einige sehr aktuelle Funktionen. lund Lsind Zeichenklassen für Groß- und Kleinbuchstaben. overweist auf den anderen Zeichensatz der Transliteration und Rkehrt ihn um. Die beiden Zeichensätze erweitern sich also zu:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba

Sie werden feststellen, dass dies den Fall vertauscht, während Sie den Atbash-Chiffriervorgang ausführen, aber der abschließende Vergleich wird trotzdem ohne Berücksichtigung der Groß- und Kleinschreibung durchgeführt.

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

Nun kehren wir die zweite Kopie um. Leider hat Retina noch keine bequeme Möglichkeit, dies zu tun, daher müssen wir jeweils einen Charakter vom Ende nach vorne verschieben. Dies geschieht, indem der Zeilenvorschubtrenner als Markierung verwendet wird, deren Teil noch nicht umgekehrt wurde. Wir stimmen mit diesem Teil überein, erfassen jedoch das letzte Zeichen separat. Dieses Zeichen steht vorne und der Rest bleibt unverändert. Das +sagt Retina, dies wiederholt zu tun, bis es nicht mehr möglich ist (weil es am Ende der Zeichenkette ist).

i`^(.+)\1$

Schließlich prüfen wir, ob die beiden Zeichenfolgen identisch sind. Das imacht das Muster unabhängig von Groß- und Kleinschreibung - in .NET bedeutet dies, dass Rückverweise auch unabhängig von Groß- und Kleinschreibung sind. Möglicherweise stellen Sie fest, dass zwischen der ursprünglichen Eingabe und der geänderten Kopie kein Trennzeichen mehr vorhanden ist. Wir brauchen aber keine, weil sie gleich lang sind, und wenn die Zeichenfolge jetzt genau zweimal (bis auf Groß- / Kleinschreibung) aus derselben Zeichenfolge besteht, müssen dies die ursprüngliche und die geänderte Zeichenfolge sein. Wenn Sie sich fragen, was mit dem nachfolgenden Zeilenvorschub geschehen ist, den wir als Markierung verwendet haben, ist er immer noch vorhanden. In vielen Regex-Varianten wird jedoch $auch vor dem letzten Zeichen der Zeichenfolge eine Übereinstimmung gefunden, wenn es sich bei diesem Zeichen um einen Zeilenvorschub handelt.

Da diese Phase nur aus einer einzigen Zeile besteht, wird sie als Match-Phase betrachtet, in der die Anzahl der Matches gezählt wird. Wenn die Eingabe ein Atbash-Palindrom ist, erhalten wir genau eine Übereinstimmung und die Ausgabe ist 1. Wenn nicht, stimmt dieser reguläre Ausdruck nicht überein und die Ausgabe erfolgt 0.

Martin Ender
quelle
Ich denke, es ist besser, Linefeeds als Bühnentrenner und Pilcrows als wörtliche als umgekehrt zu haben.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Der Einfachheit halber können Sie Zeilenvorschübe auch durch Escape-Sequenzen, \n in Regex und $nin Substitution einfügen , dies ist jedoch eine Verschwendung von Byte für das Golfen. ;)
Martin Ender
5

GNU Sed, 105

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

Gibt 1 für wahr und 0 für falsch aus.

Ich habe versucht, dies in Retina zu tun, konnte aber nicht herausfinden, wie der String vor der Atbash-Transliteration für den umgekehrten Vergleich mit after gespeichert werden kann. Vielleicht gibt es einen besseren Weg.

Der yTranskriptionsbefehl von Sed lässt zu wünschen übrig.

Digitales Trauma
quelle
Ja, das "Speichern" von Dingen ist in Retina immer noch umständlich. Sie müssten die Zeichenfolge duplizieren und dann nur eine Kopie transliterieren und umkehren. Ich möchte in Zukunft eine Art Verzweigungs- / Verzweigungsfunktion hinzufügen, bin mir aber hinsichtlich der Details noch nicht ganz sicher.
Martin Ender
Ah, ich denke, ich verstehe - ich habe versucht, etwas Ähnliches zu tun, indem ich die Zeichenfolgen vor und nach mit einem Doppelpunkt getrennt habe. Ich bin am Ende des Regex gestürzt T- ich habe angenommen, dass er für jedes Zeichen der Reihe nach gilt, aber wenn ich es richtig verstehe, gilt er für den gesamten Musterraum, was viel nützlicher ist
Digitales Trauma
1
Der reguläre Ausdruck in T wird auf die Eingabezeichenfolge angewendet. Die Transliteration ist die einzige, die innerhalb der Spiele dieses regulären Ausdrucks ausgeführt wird, und alles, was nicht übereinstimmt, bleibt unverändert. Der reguläre Ausdruck ist standardmäßig [\s\S]+so, dass Sie alles transliterieren, indem Sie ihn weglassen.
Martin Ender
Wie du möchtest. :)
Martin Ender
Da es sich um GNU Sed handelt, können Sie ein Byte speichern, indem Sie das -rFlag für die Backslashes in \(und tauschen \). Ich stimme dir in dem yBefehl zu!
Toby Speight
4

𝔼𝕊𝕄𝕚𝕟 15 Zeichen / 30 Bytes

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

Try it here (Firefox only).

Erläuterung

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

Parenthetic, 658 Bytes

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

Funktioniert derzeit nur für Großbuchstaben ohne Leerzeichen. Verwenden Sie dazu diese geänderte Version des Skripts, sodass das Lesen von stdin unterstützt wird:

#!/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'

Erläuterung

(
  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
quelle
4
Soll Ihr Code der längste sein? : P
Zorgatone
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)))

Wir konvertieren die Eingabe in Großbuchstaben und berechnen dann den String Atbashed, indem wir alle Ordinalzahlen von 155 subtrahieren, wenn sie im Großbuchstabenbereich liegen.

Lirtosiast
quelle
4

Kerf , 73 Bytes

Kerf ist eine proprietäre Sprache in derselben allgemeinen Familie wie APL, J und K. Es ist möglich, kryptische, kompakte Oneliners zu schreiben und die Verwendung expliziter Schleifen zu vermeiden:

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

Die Verwendung der buchstabierten Aliase für Befehle anstelle der Kurzsymbole und der Verwendung aussagekräftiger Bezeichner macht das Programm jedoch viel übersichtlicher und relativ einfach zu befolgen, selbst wenn Sie mit Kerf nicht vertraut sind:

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

In Aktion:

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 wird wahrscheinlich nicht viele Codegolfwettbewerbe gewinnen, insbesondere nicht gegen speziell entwickelte Sprachen, aber es könnte sich lohnen, daran zu basteln, wenn Sie die Idee von Sprachen der APL-Familie mögen, die Syntax aber zu seltsam finden. ( Haftungsausschluss: Ich bin der Autor des Referenzhandbuchs für Kerf. )

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

Dies wird mit einem Atom als Eingabe bezeichnet, z a('WIZARD')..

Tödlich
quelle
3

JavaScript (ES6), 91

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

PRÜFUNG

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>
Erweitern Sie das Snippet

edc65
quelle
3

C 101 97 Bytes

Da die Frage ASCII-Zeichen angibt, werden keine anderen Codierungen verarbeitet. 

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

Erläuterung

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

Wir machen einen Zeiger p, der am Ende der Zeichenkette beginnt. Wir machen dann eine Schleife und bewegen uns beide sund paufeinander zu sbis zum Ende. Dies bedeutet, dass jedes Zeichenpaar zweimal überprüft wird, dies spart jedoch ein paar Bytes im Vergleich zum Anhalten, sobald die Zeiger überkreuzen.

Bei jeder Iteration prüfen wir, ob *pes sich um einen Buchstaben handelt. Ist dies der Fall, prüfen Sie, ob *sder Buchstabenbereich (ASCII 64 aufwärts) *pund der *sWert 27 (Mod 32) beträgt . Nicht-Buchstaben über 64 bestehen diesen Test nicht, sodass wir nicht prüfen müssen isalpha(*s).

Wenn *pes sich nicht um einen Buchstaben handelt, testen wir einfach, ob er gleich ist *s. In beiden Fällen beenden wir die Schleife vor sund pkreuzen über.

Wenn sund pgekreuzt haben, stimmen alle Buchstabenpaare überein, sodass wir true zurückgeben. Andernfalls geben wir false zurück.

Testprogramm

Übergeben Sie die zu testenden Zeichenfolgen als Befehlszeilenargumente. Dies führt zu einer korrekten Ausgabe für alle Testfälle. Für die leere Zeichenfolge ist keine Angabe erforderlich. Meine Implementierung gibt für diese Eingabe false zurück.

#include <stdio.h>

int main(int argc, char **argv)
{
    while (*++argv)
        printf("\"%s\" => %s\n", *argv, f(*argv)?"true":"false");
    return 0;
}
Toby Speight
quelle
Sie können die ff(char*s)
cat
3

Perl 5, 70 Bytes

Ein Unterprogramm:

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

Sehen Sie es in Gebrauch:

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

MATL, 23 Bytes

Verwendet die aktuelle Version .

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

Beispiele

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

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

CJam, 18 Bytes

qeu_'[,65>_W%erW%=

Probieren Sie es online aus

Konvertiert Eingaben in Großbuchstaben, führt die Übersetzung von Buchstaben durch, dreht die Zeichenfolge um und überprüft die Gleichheit.

GamrCorps
quelle
2

Japt, 30 27 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Dies basiert größtenteils auf meiner Japt-Antwort auf 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
quelle
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]

Grundsätzlich wird ein Wörterbuch der Übersetzung mit Großbuchstaben erstellt und die Eingabe wird in Großbuchstaben geschrieben (wenn stattdessen alles in Kleinbuchstaben geschrieben wäre, würden 5 Bytes hinzugefügt). Führen Sie dann für jedes Zeichen in der Eingabe mit Großbuchstaben die Übersetzung durch und hängen Sie es an eine Liste an, es sei denn, das Zeichen befindet sich nicht im Alphabet. In diesem Fall hängen Sie das Zeichen so an, wie es ist. Trete der gesamten Liste bei und vergleiche mit der umgekehrten Liste.

Schreiben Sie an @Artyer, dass Sie fast genau das gepostet haben, was ich vor mir gepostet habe. Aber ich muss bestätigen, das ist meine Arbeit und ich habe dies unabhängig gemacht .

Basierend auf der Julia-Antwort von Alex A. Probieren Sie es hier aus

TanMath
quelle
Es folgt ein unnötiges Leerzeichen .get(i,i). +1.
Yytsi
1

05AB1E , 8 Bytes (nicht konkurrierend)

Diese Sprache verwendet Funktionen, die die Herausforderung nachträglich bearbeiten und daher nicht konkurrieren.

Code:

lDAAR‡RQ

Erläuterung:

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

Probieren Sie es online!

Adnan
quelle
1

Faktor 118 113 Bytes

Dies ist eine anonyme Funktion.

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

Ich kenne keinen kürzeren Weg, um ein assoziatives Array des Alphabets zu erzeugen: c

Katze
quelle
1

Clojure, 100 Bytes

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

Es sollte möglich sein, es auf eine einzige anonyme Funktion zu beschränken, die etwa 10 weitere Bytes (Deklarationen) schneidet, aber ich habe noch keinen Weg gefunden.

Michael M
quelle
1

Ruby, 79 77 Bytes

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

Akzeptiert das zu testende Wort als Befehlszeilenargument. Beendet mit Code 0 (der der Shell entspricht), wenn das Argument ein atbash-Selbst-Palindrom ist, oder mit Code 1, wenn dies nicht der Fall ist.

PellMell
quelle
1
Wäre putsdas Ergebnis nicht kürzer als ein Exit mit einem Ternary?
Katze
FYI $*ist ein Alias ​​für ARGV.
Jordanien
1

Ruby, 56 Bytes

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

Es ist eine anonyme Funktion, die eine Zeichenfolge akzeptiert und trueoder zurückgibt false. Es ist ziemlich umständlich: Um ein paar Bytes zu sparen, verwendet es die destruktive Variante von upcase(mit einem !danach). upcase!Gibt leider zurück, nilwenn nichts geändert wird (wie bei allen numerischen Eingaben), sodass einige Bytes verloren gehen, wenn versucht wird, damit umzugehen. Funktioniert immer noch :)

daniero
quelle
1

MATLAB, 61 Bytes

Nicht die kürzeste Lösung, aber trotzdem interessant

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