Atbash Self Palindromes

27

Pertimbangkan transformasi 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

Di mana A ⇔ Z dan L ⇔ O, misalnya Ada properti menarik yang dibagikan oleh beberapa kata. Ketika beberapa string diterjemahkan ke atbash-equivalen mereka, kata terjemahan adalah kata aslinya dibalik. Saya menyebutnya Atbash Self Palindromes .

Sebagai contoh, mari terjemahkan WIZARD :

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

Hasilnya adalah DRAZIW , yang WIZARD terbalik. Jadi, WIZARD adalah palbrom self atbash.

Objective Diberikan string karakter ASCII yang dapat dicetak, mengeluarkan atau mengembalikan nilai kebenaran jika string tersebut adalah atbash self palindrome, dan nilai falsey sebaliknya. (Ini dilakukan melalui STDIN, setara terdekat, input fungsional, dll. Jika bahasa Anda tidak dapat melakukan semua ini, pertimbangkan untuk memilih bahasa yang berbeda Anda dapat meng-hardcode input tersebut.) Anda harus melakukan hal ini secara tidak sensitif. Jika inputnya adalah palindrome dan tidak terpengaruh oleh atbash seqeunce, Anda harus tetap menampilkan true, karena palindrom + sendiri adalah palindrom. Ini adalah kode-golf , jadi program terpendek dalam byte menang.

Uji kasus

"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

Papan peringkat

Cuplikan Stack di bagian bawah posting ini menghasilkan katalog dari jawaban a) sebagai daftar solusi terpendek per bahasa dan b) sebagai leaderboard keseluruhan.

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

## Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda dapat menyimpan skor lama di headline, dengan mencoretnya. Contohnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar hukuman penterjemah secara terpisah), pastikan bahwa skor sebenarnya adalah angka terakhir di tajuk:

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

Anda juga dapat membuat nama bahasa menjadi tautan yang kemudian akan muncul di cuplikan:

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

Tampilkan cuplikan kode

code-golf string cryptography palindrome Conor O'Brien
sumber
Terkait: Tukar Alfabet .
nicael
4
AtBash sebenarnya bukan hal yang baru. Ini adalah transformasi huruf Ibrani Kabala (Mistisisme Yahudi) yang setara dengan ini. Karena bahasa Ibrani hanya ditulis dengan wovel, string huruf apa saja dapat dibaca dengan memasukkan wovel acak. ATB (a) SH adalah mnemonik untuk mentransformasikan Alef (huruf Ibrani pertama) menjadi Tav (terakhir), Beis (kedua) menjadi SHin (berikutnya-terakhir).
Adám
1
Pertimbangkan untuk memberikan poin -1000000 jika kode solusi seseorang itu sendiri merupakan palbrom self atbash? : p
kojiro
3
@kojiro Non-sepele yang bertentangan dengan code {Comment-symbol}{Atbash'ed Comment-symbol} Atbash'ed code...
Adám
1
@ mbomb007 Saya katakan saya dapat menawarkan hadiah jika program nontrivial ditemukan
Conor O'Brien

Jawaban:

8

RX , 9 8 byte

Sangat terinspirasi oleh Retina, saya membuatnya beberapa hari yang lalu. Kode:

prR`w$rM

Penjelasan:

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.

Coba di sini !

Adnan
sumber
Jadi, bagaimana bahasa itu sendiri benar-benar berfungsi? Apakah ini semacam bahasa pemrosesan string berbasis stack? Ini benar-benar mengesankan, tetapi sejauh yang saya tahu tidak ada cara untuk mengulang dalam bahasa yang berarti sangat tidak mungkin bahwa ini memenuhi standar bahasa pemrograman kami pada tahap ini.
Martin Ender
@ MartinBüttner Bahasa ini terutama didasarkan pada pemrosesan input menggunakan model tumpukan. Itu tidak menggunakan bilangan bulat (dan mungkin tidak akan pernah). Saya sudah mengimplementasikan loop, tetapi versi itu belum dirilis.
Adnan
@Martin Regexes mampu menguji sendiri keaslian, jadi saya cukup yakin ini valid.
lirtosiast
@ThomasKwa Sejauh yang saya lihat, penerjemah tidak menggunakan ekspresi reguler aktual apa pun.
Martin Ender
@ Martin Hmm, kau benar.
lirtosiast
11

Pyth, 10 9 byte

qJrz0_XJG

Coba biola ini secara online atau verifikasi semua uji sekaligus.

Penjelasan

qJrz0_XJG
  rz0      Lowercase input
 J         Store a copy in J
     _XJG  Translate J with the reverse alphabet and reverse
q          Compare
sebuah spaghetto
sumber
3
Karena Anda menggunakan rz0dua kali, bukankah lebih pendek untuk menyimpannya ke variabel?
xnor
1
Seperti yang disarankan @xnor, q_Jrz0XJGsatu byte lebih pendek.
PurkkaKoodari
6

Julia, 96 byte

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

Ini adalah fungsi lambda yang menerima string dan mengembalikan string. Untuk menyebutnya, tetapkan ke variabel.

Tidak Disatukan:

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

Utilitas Bash + Linux, 56

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

Menghasilkan string kosong untuk Truthy dan sesuatu seperti - /dev/fd/63 differ: byte 1, line 1untuk Falsey. Jika ini tidak dapat diterima maka kita dapat menambahkan -s3 byte tambahan dan menggunakan kode pengembalian Unix standar 0 untuk Sukses (Kebenaran) dan 1 untuk Kegagalan (Falsey).

Trauma Digital
sumber
5

Retina , 44 byte

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

Cetakan 1atau 0. Hitungan byte mengasumsikan bahwa file dikodekan sebagai ISO 8859-1.

Cobalah online!

Jawaban ini sebagian besar terinspirasi oleh jawaban sed DigitalTrauma tapi sekali lagi saya kira tidak ada banyak pendekatan untuk tantangan ini di tempat pertama.

Penjelasan

Setiap kali Anda melihat , hal pertama yang Retina lakukan setelah memecah kode menjadi garis-garis adalah mengganti semua pilcrow tersebut dengan linefeeds. Ini memungkinkan pemasukan dari linefeeds untuk satu byte walaupun linefeeds adalah pemisah stage Retina.

$
¶$_

Kami mulai dengan menduplikasi input. Kami mencocokkan akhir input dengan $dan menyisipkan linefeed bersama dengan input itu sendiri (menggunakan $_).

T`lL`Ro`.+$

Tahap transliterasi. Mari kita mulai dengan regex: .+$. Ini cocok dengan salinan input kedua (dengan memastikan kecocokan berlangsung hingga akhir string). Jadi hanya karakter dalam salinan kedua yang akan ditransliterasi. Transliterasi itu sendiri menggunakan beberapa fitur yang sangat baru. ldan Lkelas karakter untuk huruf kecil dan huruf besar, masing-masing. omerujuk ke set karakter lain dari transliterasi dan Rmembalikkannya. Jadi dua set karakter berkembang ke:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba

Anda akan melihat bahwa ini menukar case saat melakukan cypher Atbash, tetapi bagaimanapun kami akan melakukan perbandingan case-insensitive.

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

Sekarang kita membalikkan salinan kedua. Sayangnya, Retina belum memiliki cara yang mudah untuk melakukan itu, jadi kita harus memindahkan satu karakter dari ujung ke depan sekaligus. Ini dilakukan dengan repurposing pemisah linefeed sebagai penanda yang bagiannya belum terbalik. Kami mencocokkan bagian itu tetapi menangkap karakter terakhir secara terpisah. Karakter itu berjalan di depan, dan sisanya tidak berubah. The +memberitahu Retina untuk melakukan hal ini berulang-ulang sampai itu tidak mungkin lagi (karena berada di akhir string).

i`^(.+)\1$

Akhirnya, kami memeriksa apakah kedua senarnya sama. The imembuat pola case-sensitive - nyaman, NET, ini berarti bahwa backreferences juga kasus-sensitif. Anda mungkin memperhatikan bahwa kami tidak lagi memiliki pemisah antara input asli dan salinan yang dimodifikasi. Kita tidak memerlukan satu, karena mereka memiliki panjang yang sama, dan jika string sekarang terdiri dari string yang sama persis dua kali (sesuai kasus), maka mereka harus yang asli dan string yang dimodifikasi. Jika Anda bertanya-tanya apa yang terjadi pada trafeed linefeeding yang kami gunakan sebagai marker, itu masih ada, tetapi dalam banyak rasa regex $juga cocok sebelum karakter terakhir dari string jika karakter itu adalah linefeed.

Karena tahap ini hanya terdiri dari satu baris, maka dianggap sebagai tahap pertandingan, yang menghitung jumlah pertandingan. Jika inputnya adalah palindrome Atbash, kami akan mendapatkan tepat satu kecocokan dan hasilnya adalah 1. Jika tidak, maka regex ini tidak akan cocok dan hasilnya akan 0.

Martin Ender
sumber
Saya kira lebih baik untuk memiliki linefeeds menjadi pemisah panggung dan pilcrows menjadi literal daripada sebaliknya.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Untuk kenyamanan, Anda juga dapat memasukkan umpan baris dengan urutan escape, \n dalam regex dan $ndalam substitusi, tetapi itu menghabiskan byte untuk bermain golf. ;)
Martin Ender
5

GNU Sed, 105

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

Output 1 untuk truey dan 0 untuk falsey.

Saya mencoba melakukan ini di Retina, tetapi tidak tahu bagaimana cara menyimpan string sebelum Atbash transliterasi untuk perbandingan terbalik dengan setelah. Mungkin ada cara yang lebih baik.

yPerintah transliterasi Sed meninggalkan banyak hal yang diinginkan.

Trauma Digital
sumber
Ya, "menyimpan" hal-hal masih rumit di Retina. Anda harus menduplikasi string dan kemudian transliterasi dan membalikkan hanya satu salinan. Saya ingin menambahkan semacam fitur percabangan / forking di masa depan, tapi saya belum yakin tentang detailnya.
Martin Ender
Ah, saya rasa saya mengerti - saya mencoba melakukan sesuatu yang serupa dengan memisahkan string sebelum dan sesudah dengan titik dua. Saya jatuh dengan regex pada akhir T- saya berasumsi itu diterapkan pada setiap karakter pada gilirannya, tetapi jika pemahaman saya benar, itu berlaku untuk seluruh ruang pola, yang jauh lebih berguna
Digital Trauma
1
Regex di T diterapkan ke string input. Transliterasi adalah satu-satunya yang dilakukan dalam kecocokan dari regex itu dan semua yang tidak tertandingi dibiarkan tidak berubah. Regex default [\s\S]+jadi dengan menghilangkannya, Anda mentransliterasi semuanya.
Martin Ender
Sesuai keinginan kamu. :)
Martin Ender
Karena ini GNU sed, Anda dapat menyimpan byte dengan -rflag perdagangan untuk backslash di \(dan \). Saya setuju dengan Anda pada yperintah!
Toby Speight
4

𝔼𝕊𝕄𝕚𝕟, 15 karakter / 30 byte

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

Try it here (Firefox only).

Penjelasan

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

Parenthetic, 658 byte

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

Hanya berfungsi untuk semua huruf besar tanpa spasi putih sekarang, menggunakan versi skrip yang dimodifikasi ini sehingga mendukung pembacaan dari 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'

Penjelasan

(
  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
sumber
4
Apakah Anda ingin kode Anda menjadi yang terpanjang? : P
Zorgatone
4

Python 3, 90 85 byte

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

Kami mengonversi input ke huruf besar, dan kemudian menghitung string Atbashed dengan mengurangi semua ordinals dari 155 jika mereka berada dalam kisaran alfabet huruf besar.

lirtosiast
sumber
4

Garitan , 73 byte

Kerf adalah bahasa berpemilik dalam keluarga umum yang sama dengan APL, J dan K. Dimungkinkan untuk menulis oneliner yang samar dan ringkas dan menghindari penggunaan loop eksplisit:

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

Namun, menggunakan alias yang dieja untuk perintah alih-alih simbol steno dan menggunakan pengidentifikasi yang berarti membuat program lebih jelas, dan cukup mudah diikuti bahkan jika Anda tidak terbiasa dengan 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]
}

Dalam aksi:

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]

Garitan mungkin tidak akan memenangkan satu ton kompetisi codegolf, terutama terhadap bahasa yang dibangun khusus, tetapi mungkin layak untuk bermain-main jika Anda menyukai gagasan bahasa keluarga APL tetapi menemukan sintaksinya terlalu aneh. ( Penafian: Saya penulis manual referensi untuk Kerf. )

JohnE
sumber
3

Prolog, 121 byte

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

Ini disebut dengan atom sebagai input, mis a('WIZARD')..

Fatalisasi
sumber
3

JavaScript (ES6), 91

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

UJI

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>
Luaskan cuplikan

edc65
sumber
3

C, 101 97 byte

Seperti pertanyaan yang ditentukan karakter ASCII, ini tidak menangani pengkodean lainnya. 

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

Penjelasan

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

Kami membuat pointer pyang dimulai pada akhir string. Kami kemudian mengulang, menggerakkan keduanya sdan pmenuju satu sama lains mencapai akhir. Ini berarti bahwa setiap pasangan karakter akan diperiksa dua kali, tetapi ini menghemat beberapa byte dibandingkan dengan berhenti begitu pointer melewati.

Pada setiap iterasi, kami memeriksa apakah *pada surat. Jika demikian, periksa bahwa *sada dalam kisaran huruf (ASCII 64 ke atas), dan itu *pdan*s tambahkan hingga 27 (mod 32). Non-huruf di atas 64 akan gagal dalam tes itu, jadi kami tidak perlu memeriksa isalpha(*s).

Jika *pbukan huruf, maka kita cukup menguji apakah itu sama dengan *s. Dalam kedua kasus, kami mengakhiri loop sebelum sdanp menyeberang.

Jika sdanp telah menyeberang, maka setiap pasangan huruf cocok dengan benar, jadi kami mengembalikan true; kalau tidak kita kembali salah.

Program uji

Lewati string yang akan diuji sebagai argumen baris perintah. Ini menghasilkan output yang benar untuk semua kasus uji. Tidak ada persyaratan yang disediakan untuk string kosong; implementasi saya mengembalikan false untuk input itu.

#include <stdio.h>

int main(int argc, char **argv)
{
    while (*++argv)
        printf("\"%s\" => %s\n", *argv, f(*argv)?"true":"false");
    return 0;
}
Toby Speight
sumber
Anda dapat menjatuhkan fdeklarasi tipe untuk prototipe gaya K&R:f(char*s)
cat
3

Perl 5, 70 byte

Subrutin:

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

Lihat ini digunakan:

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

MATL, 23 byte

Menggunakan rilis saat ini .

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

Contohnya

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

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

CJam, 18 byte

qeu_'[,65>_W%erW%=

Cobalah online

Bekerja dengan mengonversi input ke huruf besar, melakukan terjemahan huruf, membalik string, dan memeriksa kesetaraan.

GamrCorps
sumber
2

Japt, 30 27 byte

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

Cobalah online!

Bagaimana itu bekerja

Ini sebagian besar didasarkan pada jawaban Japt saya di 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
Produksi ETH
sumber
1

Python, 156 112 byte

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]

Pada dasarnya, ini membuat kamus terjemahan dengan huruf besar dan input ditulis dengan huruf besar (jika semuanya huruf kecil sebagai gantinya, itu akan menambah 5 byte). Kemudian, untuk setiap karakter dalam input huruf besar, lakukan terjemahan dan tambahkan ke daftar kecuali karakter tersebut tidak ada dalam alfabet, dalam hal ini tambahkan karakter apa adanya. Bergabunglah dengan seluruh daftar dan bandingkan dengan daftar terbalik.

Berteriaklah ke @Artyer karena memposting hampir persis seperti yang akan saya posting sebelumnya. Tapi saya perlu mengkonfirmasi, ini adalah pekerjaan saya dan saya melakukan ini secara mandiri .

Berdasarkan pada jawaban Julia oleh Alex A. Cobalah di sini

TanMath
sumber
Ada spasi putih yang tidak perlu setelahnya .get(i,i). +1.
Yytsi
1

05AB1E , 8 byte (tidak bersaing)

Bahasa ini menggunakan fitur-fitur yang menunda tantangan dan karenanya tidak bersaing.

Kode:

lDAAR‡RQ

Penjelasan:

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

Cobalah online!

Adnan
sumber
1

Factor, 118 113 byte

Ini adalah fungsi anonim.

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

Saya tidak tahu cara yang lebih pendek untuk menghasilkan array asosiatif dari alfabet: c

kucing
sumber
1

Clojure, 100 byte

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

Seharusnya dimungkinkan untuk memotongnya ke fungsi anonim tunggal, memotong sekitar 10 byte lebih (dari deklarasi) tapi saya belum menemukan cara.

Michael M.
sumber
1

Ruby, 79 77 byte

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

Menerima kata untuk diuji sebagai argumen baris perintah. Keluar dengan kode 0 (yang sesuai dengan shell) jika argumennya adalah atbash self palindrome, atau dengan kode 1 sebaliknya.

Tdk teratur
sumber
1
Bukankah putshasilnya lebih pendek daripada keluar dengan terner?
kucing
FYI $*adalah alias untuk ARGV.
Jordan
1

Ruby, 56 byte

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

Ini adalah fungsi anonim yang mengambil string dan mengembalikan trueatau false. Agak canggung: Untuk menghemat beberapa byte, ia menggunakan varian destruktif dari upcase(dengan !setelahnya). upcase!sayangnya kembali niljika tidak ada yang berubah (seperti semua input numerik), sehingga beberapa byte hilang saat mencoba untuk menghadapinya. Masih berfungsi :)

daniero
sumber
1

MATLAB, 61 byte

Bukan solusi terpendek, tapi tetap menarik

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