Atbash Self Palindromes

27

Rozważ transformację 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

Gdzie A ⇔ Z i L ⇔ O, np. Istnieje interesująca właściwość, którą dzielą niektóre słowa. Kiedy niektóre ciągi są tłumaczone na ich odpowiednik atbash, wspomniane tłumaczenie jest oryginalnym wyrazem odwróconym. Nazywam te Autopalinde Atbash .

Na przykład przetłumaczmy WIZARD :

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

Wynikiem jest DRAZIW , który jest odwrócony WIZARD . Zatem WIZARD jest szyfr atbash własnym palindrom.

Cel Biorąc pod uwagę ciąg znaków ASCII do wydrukowania, wyślij lub zwróć prawdziwą wartość, jeśli ciąg ten jest samo-palindromem atbash, a w przeciwnym razie wartością falsey. (Odbywa się to poprzez STDIN, najbliższy odpowiednik, funkcjonalne dane wejściowe itp. Jeśli twój język nie może wykonać żadnego z tych, rozważ wybór innego języka, w którym możesz wprowadzić kod na stałe.) Powinieneś to zrobić bez rozróżniania wielkości liter. Jeśli wejściem jest palindrom i nie ma na niego wpływu sekwencja atbash, powinieneś nadal generować wartość true, ponieważ sam palindrom + jest palindromem. To jest golf golfowy , więc wygrywa najkrótszy program w bajtach.

Przypadki testowe

"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

Tabela liderów

Fragment kodu na dole tego postu generuje katalog na podstawie odpowiedzi a) jako listy najkrótszych rozwiązań dla każdego języka oraz b) jako ogólnej tabeli wyników.

Aby upewnić się, że Twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

## Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie:

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

Pokaż fragment kodu

code-golf string cryptography palindrome Conor O'Brien
źródło
Powiązane: Zamień alfabet .
nicael
4
AtBash tak naprawdę nie jest niczym nowym. Jest to odpowiednik hebrajskiej transformacji liter hebrajskich Kabala (żydowski mistycyzm). Ponieważ hebrajski jest pisany tylko za pomocą wavels, każdy ciąg liter można odczytać, wstawiając losowe wavels. ATB (a) SH to mnemonik do przekształcania Alefa (pierwsza litera hebrajska) na Tav (ostatni), Beis (drugi) na SHin (następny-ostatni).
Adám
1
Zastanów się nad przyznaniem -1000000 punktów, jeśli czyjś kod rozwiązania sam w sobie jest palindromem atbash? : p
kojiro
3
@kojiro Nietrywialne w przeciwieństwie do code {Comment-symbol}{Atbash'ed Comment-symbol} Atbash'ed code...
Adám
1
@ mbomb007 Powiedziałem, że mogę zaoferować nagrodę, jeśli taki nietrywialny program zostanie znaleziony
Conor O'Brien

Odpowiedzi:

8

RX , 9 8 bajtów

Mocno zainspirowany Retiną, zrobiłem to kilka dni temu. Kod:

prR`w$rM

Wyjaśnienie:

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.

Wypróbuj tutaj !

Adnan
źródło
Jak więc właściwie działa sam język? Czy jest to jakiś język przetwarzania łańcucha oparty na stosie? To naprawdę imponujące, ale o ile wiem, nie ma jeszcze możliwości zapętlenia języka, co oznacza, że ​​jest bardzo mało prawdopodobne, aby spełniało ono nasze standardy języka programowania na tym etapie.
Martin Ender
@ MartinBüttner Ten język opiera się głównie na przetwarzaniu danych wejściowych przy użyciu modelu stosu. Nie używa liczb całkowitych (i prawdopodobnie nigdy nie będzie). Zaimplementowałem pętlę, ale ta wersja nie została jeszcze wydana.
Adnan
@Martin Regexes są w stanie samodzielnie przetestować pierwotność, więc jestem pewien, że jest to poprawne.
lirtosiast
@ThomasKwa Z tego, co widzę, tłumacz nie używa żadnych faktycznych wyrażeń regularnych.
Martin Ender
@Martin Hmm, masz rację.
lirtosiast
11

Pyth, 10 9 bajtów

qJrz0_XJG

Wypróbuj to skrzypce online lub sprawdź jednocześnie wszystkie przypadki testowe.

Wyjaśnienie

qJrz0_XJG
  rz0      Lowercase input
 J         Store a copy in J
     _XJG  Translate J with the reverse alphabet and reverse
q          Compare
spaghetto
źródło
3
Ponieważ używasz rz0dwa razy, czy nie jest krótsze zapisanie go w zmiennej?
xnor
1
Jak sugeruje @xnor, q_Jrz0XJGjest o jeden bajt krótszy.
PurkkaKoodari
6

Julia, 96 bajtów

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

Jest to funkcja lambda, która przyjmuje ciąg i zwraca ciąg. Aby go wywołać, przypisz go do zmiennej.

Nie golfowany:

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.
źródło
5

Narzędzia Bash + Linux, 56

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

Zwraca pusty ciąg dla Truthy i coś takiego jak - /dev/fd/63 differ: byte 1, line 1dla Falsey. Jeśli nie jest to do przyjęcia, możemy dodać -sdodatkowe 3 bajty i użyć standardowych kodów powrotu Unix 0 dla Success (Truthy) i 1 dla Failure (Falsey).

Cyfrowa trauma
źródło
5

Siatkówka , 44 bajty

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

Odbitki 1lub 0. Liczba bajtów zakłada, że ​​plik jest zakodowany jako ISO 8859-1.

Wypróbuj online!

Ta odpowiedź była w dużej mierze zainspirowana odpowiedzią sed firmy DigitalTrauma, ale wydaje mi się, że nie ma zbyt wielu podejść do tego wyzwania.

Wyjaśnienie

Ilekroć widzisz a , pierwszą rzeczą, którą Retina robi po podzieleniu kodu na linie, jest zastąpienie wszystkich tych pilcrows znakami linii. Pozwala to na włączenie kanałów dla jednego bajtu, mimo że kanały są separatorem etapów Retiny.

$
¶$_

Zaczynamy od skopiowania danych wejściowych. Dopasowujemy koniec wejścia do $i wstawiamy wysuw linii wraz z samym wejściem (używając $_).

T`lL`Ro`.+$

Etap transliteracji. Zacznijmy regex: .+$. Dopasowuje drugą kopię danych wejściowych (upewniając się, że dopasowanie przebiega do końca ciągu). Tak więc tylko znaki w drugiej kopii będą transliterowane. Sama transliteracja korzysta z niektórych bardzo najnowszych funkcji. li Lsą klasami znaków odpowiednio dla małych i wielkich liter. oodnosi się do drugiego zestawu znaków transliteracji i Rodwraca go. Zatem dwa zestawy znaków rozwijają się do:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba

Zauważysz, że zamienia to przypadek podczas szyfrowania Atbash, ale i tak zrobimy końcowe porównanie bez rozróżniania wielkości liter.

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

Teraz odwracamy drugą kopię. Niestety Retina nie ma jeszcze na to dogodnego sposobu, więc będziemy musieli przenosić jedną postać od końca do przodu na raz. Odbywa się to poprzez zmianę przeznaczenia separatora podawania linii jako znacznika, którego część nie została jeszcze odwrócona. Dopasowujemy tę część, ale przechwytujemy ostatnią postać osobno. Ta postać idzie na przód, a reszta pozostaje niezmieniona. +Mówi Retina to zrobić, dopóki nie jest już możliwe (bo jest na końcu łańcucha).

i`^(.+)\1$

Na koniec sprawdzamy, czy dwa ciągi są takie same. iSprawia wzorzec wielkości liter - wygodnie, w .NET, oznacza to, że wsteczne są również wielkości liter. Możesz zauważyć, że nie mamy już separatora między oryginalnym wejściem a zmodyfikowaną kopią. Nie potrzebujemy jednak jednego, ponieważ mają one tę samą długość, a jeśli łańcuch składa się teraz dokładnie z tego samego ciągu dwa razy (w zależności od wielkości liter), to muszą one być ciągiem oryginalnym i zmodyfikowanym. Jeśli zastanawiasz się, co stało się z końcowym podawaniem liniowym, którego użyliśmy jako znacznika, nadal tam jest, ale w wielu wyrażeniach regularnych $dopasowuje się również przed ostatnim znakiem ciągu, jeśli ten znak jest przesuwany.

Ponieważ ten etap składa się tylko z jednej linii, uważa się go za etap dopasowania, który liczy liczbę dopasowań. Jeśli dane wejściowe to palindrom Atbash, otrzymamy dokładnie jedno dopasowanie, a wynik to 1. Jeśli nie, to wyrażenie regularne nie będzie pasować, a wynik będzie 0.

Martin Ender
źródło
Wydaje mi się, że lepiej jest, aby linie były separatorami scen, a ścieżki były dosłowne niż odwrotnie.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Dla wygody możesz także wstawiać linie poprzez sekwencje specjalne, \n wyrażenia regularne i $npodstawienia, ale to zmarnowane bajty na grę w golfa. ;)
Martin Ender
5

GNU Sed, 105

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

Wyjście 1 dla prawdy i 0 dla falsey.

Próbowałem to zrobić w Retinie, ale nie mogłem wymyślić, jak zapisać ciąg przed transliteracją Atbash do odwrotnego porównania z późniejszym. Być może istnieje lepszy sposób.

yKomenda transliteracji Seda pozostawia wiele do życzenia.

Cyfrowa trauma
źródło
Tak, „przechowywanie” rzeczy wciąż jest uciążliwe w Retinie. Będziesz musiał zduplikować ciąg, a następnie transliterować i odwrócić tylko jedną kopię. Chcę w przyszłości dodać funkcję rozgałęziania / rozwidlania, ale nie jestem jeszcze pewien szczegółów.
Martin Ender
Ach, myślę, że rozumiem - próbowałem zrobić coś podobnego, oddzielając ciągi przed i za ciągiem za pomocą dwukropka. Upadłem z wyrażeniem regularnym na końcu T- zakładałem, że stosuje się go kolejno do każdej postaci, ale jeśli moje zrozumienie jest słuszne, dotyczy całej przestrzeni wzorów, co jest znacznie bardziej przydatne
Digital Trauma
1
Wyrażenie regularne w T jest stosowane do ciągu wejściowego. Transliteracja jest jedyną wykonywaną w dopasowaniach tego wyrażenia regularnego i wszystko, co nie ma sobie równych, pozostaje niezmienione. Wyrażenie regularne ma wartość domyślną, [\s\S]+więc pomijając go, transliterujesz wszystko.
Martin Ender
Jak sobie życzysz. :)
Martin Ender
Ponieważ jest to GNU sed, możesz zapisać bajt, wymieniając -rflagę na odwrotne ukośniki w \(i \). Zgadzam się z tobą na yrozkaz!
Toby Speight
4

𝔼𝕊𝕄𝕚𝕟, 15 znaków / 30 bajtów

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

Try it here (Firefox only).

Wyjaśnienie

ïþ)Ī(ᶐ,ᶐᴙ)ᴙ≔ïþ) // 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
źródło
4

Nawias, 658 bajtów

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

Działa tylko teraz dla wszystkich wielkich liter bez białych znaków, używając tej zmodyfikowanej wersji skryptu, aby obsługiwał czytanie ze standardowego wejścia:

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

Wyjaśnienie

(
  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
      (() (((()))))
    )
  )
)
Złupić
źródło
4
Czy chcesz, aby Twój kod był najdłuższy? : P
Zorgatone
4

Python 3, 90 85 bajtów

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

Konwertujemy dane wejściowe na wielkie litery, a następnie obliczamy ciąg Atbashed, odejmując wszystkie liczby porządkowe od 155, jeśli są w zakresie dużych liter alfabetu.

lirtosiast
źródło
4

Kerf , 73 bajty

Kerf jest zastrzeżonym językiem z tej samej ogólnej rodziny co APL, J i K. Możliwe jest pisanie tajemniczych, kompaktowych onelinerów i unikanie użycia jawnych pętli:

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

Jednak użycie wypisanych aliasów poleceń zamiast skrótowych symboli i użycie znaczących identyfikatorów sprawia, że ​​program jest znacznie bardziej przejrzysty i dość łatwy do naśladowania, nawet jeśli nie znasz Kerfa:

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

W akcji:

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 prawdopodobnie nie wygra wielu konkursów na kodegolfa, szczególnie przeciwko specjalnie zaprojektowanym językom, ale może warto go majstrować, jeśli podoba ci się pomysł języków z rodziny APL, ale składnia jest zbyt dziwna. ( Oświadczenie: Jestem autorem podręcznika użytkownika dla Kerf. )

JohnE
źródło
3

Prolog, 121 bajtów

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

Nazywa się to atomem na wejściu, np a('WIZARD')..

Fatalizować
źródło
3

JavaScript (ES6), 91

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

TEST

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>
Rozwiń fragment kodu

edc65
źródło
3

C, 101 97 bajtów

Ponieważ pytanie określa znaki ASCII, nie obsługuje to żadnego innego kodowania. 

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

Wyjaśnienie

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

Tworzymy wskaźnik, pktóry zaczyna się na końcu łańcucha. Następnie pętla, zarówno w ruchu si pkierunku siebie sdobiegnie końca. Oznacza to, że każda para znaków zostanie sprawdzona dwukrotnie, ale oszczędza to kilka bajtów w porównaniu z zatrzymywaniem, gdy tylko wskaźniki się przekroczą.

Przy każdej iteracji sprawdzamy, czy *pjest listem. Jeśli tak, sprawdź, czy *szawiera się w zakresie liter (ASCII 64 w górę), *pi *sdodaj do 27 (mod 32). Testy inne niż litery powyżej 64 nie przejdą tego testu, więc nie musimy tego sprawdzać isalpha(*s).

Jeśli *pnie jest literą, to po prostu testujemy, czy jest równa *s. W obu przypadkach zakończymy pętlę wcześniej si przejdziemy p.

Jeśli si pzostały skrzyżowane, to każda para liter pasuje poprawnie, więc zwracamy wartość true; w przeciwnym razie zwracamy fałsz.

Program testowy

Przekaż ciągi do przetestowania jako argumenty wiersza polecenia. Daje to prawidłowe wyniki dla wszystkich przypadków testowych. Nie ma podanego wymogu dla pustego łańcucha; moja implementacja zwraca wartość false dla tego wejścia.

#include <stdio.h>

int main(int argc, char **argv)
{
    while (*++argv)
        printf("\"%s\" => %s\n", *argv, f(*argv)?"true":"false");
    return 0;
}
Toby Speight
źródło
można upuścić f„s deklarację typu dla prototypu stylu K & R:f(char*s)
kot
3

Perl 5, 70 bajtów

Podprogram:

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

Zobacz w użyciu:

print sub{...}->("W i z a r d")
msh210
źródło
2

MATL, 23 bajty

Wykorzystuje bieżącą wersję .

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

Przykłady

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

>> matl
 > jkt"@@2Y2m?_219+]h]tP=A
 > 
> W IZ ARD
0
Luis Mendo
źródło
2

CJam, 18 bajtów

qeu_'[,65>_W%erW%=

Wypróbuj online

Działa poprzez konwersję danych wejściowych na wielkie litery, wykonywanie tłumaczenia liter, odwracanie łańcucha i sprawdzanie równości.

GamrCorps
źródło
2

Japt, 30 27 bajtów

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

Wypróbuj online!

Jak to działa

Jest to w dużej mierze oparte na mojej odpowiedzi Japt na 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
ETHprodukcje
źródło
1

Python, 156 112 bajtów

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]

Zasadniczo tworzy słownik tłumaczenia wielkimi literami, a dane wejściowe są pisane wielkimi literami (gdyby zamiast tego wszystko było pisane małymi literami, dodałoby to 5 bajtów). Następnie, dla każdego znaku wielkiej litery, dokonaj tłumaczenia i dołącz do listy, chyba że znak nie znajduje się w alfabecie, w takim przypadku dopisz znak bez zmian. Dołącz do całej listy i porównaj z odwróconą listą.

Krzyczcie do @Artyer za publikowanie prawie dokładnie tak, jak zamierzałem zamieścić przede mną. Ale muszę potwierdzić, że to moja praca i zrobiłem to niezależnie .

Na podstawie odpowiedzi Julii Alexa A. Wypróbuj tutaj

TanMath
źródło
Po tym następuje niepotrzebne białe znaki .get(i,i). +1.
Yytsi
1

05AB1E , 8 bajtów (niekonkurujące)

Ten język korzysta z funkcji, które datują wyzwanie, dlatego nie jest konkurencyjny.

Kod:

lDAAR‡RQ

Wyjaśnienie:

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

Wypróbuj online!

Adnan
źródło
1

Współczynnik, 118 113 bajtów

To anonimowa funkcja.

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

Nie znam krótszego sposobu na wygenerowanie tablicy asocjacyjnej alfabetu: c

kot
źródło
1

Clojure, 100 bajtów

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

Powinno być możliwe ograniczenie go do pojedynczej anonimowej funkcji, skrócenie około 10 dodatkowych bajtów (deklaracji), ale nie znalazłem jeszcze sposobu.

Michael M.
źródło
1

Rubinowy, 79 77 bajtów

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

Akceptuje słowo do przetestowania jako argument wiersza polecenia. Wychodzi z kodem 0 (co jest zgodne z powłoką), jeśli argumentem jest atlasowy własny palindrom, lub z kodem 1 w przeciwnym razie.

PellMell
źródło
1
Czy putswynik nie byłby krótszy niż wyjście z trójcą?
kot
FYI $*to pseudonim dla ARGV.
Jordan,
1

Rubinowy, 56 bajtów

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

Jest to anonimowa funkcja, która pobiera ciąg znaków i zwraca truelub false. Jest to raczej niezdarne: w celu zaoszczędzenia niektórych bajtów używa destrukcyjnego wariantu upcase( !po nim). upcase!niestety zwraca, niljeśli nic się nie zmienia (jak wszystkie dane numeryczne), więc niektóre bajty są tracone, próbując sobie z tym poradzić. Nadal działa :)

daniero
źródło
1

MATLAB, 61 bajtów

Nie najkrótsze rozwiązanie, ale wciąż interesujące

f=@(a)~any(changem(upper(a),90:-1:65,65:90)-fliplr(upper(a)))
PieCot
źródło