Atbash Self Palindromes


27

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

A⇔ZおよびL⇔Oなど。一部の単語に共通する興味深い特性があります。一部の文字列がatbashに相当するものに翻訳されると、その翻訳は元の単語と逆になります。これらをAtbash Self Palindromesと呼びます。

例として、WIZARDを翻訳しましょう:

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

結果はDRAZIWされ、WIZARD逆転します。したがって、WIZARDはatbash self palindromeです。

目的印刷可能なASCII文字列を与え、その文字列がatbash self palindromeである場合は真実の値を出力するか、それ以外の場合は偽の値を返します。(これは、STDIN、最も近い同等の、機能的な入力などによって行われます。言語がこれらのいずれもできない場合は、入力をハードコーディングできる別の言語選択することを検討してください。)入力が回文であり、atbashシーケンスの影響を受けない場合でも、回文+自体が回文であるため、trueを出力する必要があります。これはであるため、バイト単位の最短プログラムが優先されます。

テストケース

"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

リーダーボード

この投稿の下部にあるスタックスニペットは、a)言語ごとの最短ソリューションのリストとして、b)全体的なリーダーボードとして、回答からカタログを生成します。

回答が表示されるようにするには、次のマークダウンテンプレートを使用して、見出しから回答を開始してください。

## Language Name, N bytes

N提出物のサイズはどこですか。スコアを改善する場合、古いスコアを打つことで見出しに残すことができます。例えば:

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

ヘッダーに複数の数字を含める場合(たとえば、スコアが2つのファイルの合計であるか、インタープリターフラグペナルティーを個別にリストする場合)、実際のスコアがヘッダーの最後の数字であることを確認します。

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

言語名をリンクにして、スニペットに表示することもできます。

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



4
AtBashは実際には新しいものではありません。これに相当するカバラ(ユダヤ神秘主義)ヘブライ文字の変換です。ヘブライ語は封筒でのみ書かれているため、任意の文字列はランダムな封筒を挿入することで読むことができます。ATB(a)SHは、Alef(最初のヘブライ文字)をTav(最後)、Beis(2番目)をSHin(最後から2番目)に変換するためのニーモニックです。
アダム

1
誰かのソリューションコード自体がatbash self palindromeである場合、-1000000ポイントを与えることを検討してください。:p
小次郎

3
対照的に、非自明@kojiro code {Comment-symbol}{Atbash'ed Comment-symbol} Atbash'ed code...
アダム

1
@ mbomb007このような自明でないプログラムが見つかった場合、私は賞金を提供できると言いました
コナーオブライエン

回答:


8

RX9 8バイト

Retinaに大きな影響を受け、数日前にこれを作成しました。コード:

prR`w$rM

説明:

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.

ここで試してみてください


では、言語自体は実際にどのように機能するのでしょうか?何らかのスタックベースの文字列処理言語ですか?これは非常に印象的ですが、私が知る限り、言語をループする方法はまだないため、この段階でプログラミング言語の標準を満たすことはほとんどありません。
マーティンエンダー

@MartinBüttnerこの言語は、主にスタックモデルを使用した入力の処理に基づいています。整数は使用しません(おそらく使用しません)。ループを実装しましたが、そのバージョンはまだリリースされていません。
アドナン

@Martin Regexesは、独自に素数テストを行うことができるため、これが有効であると確信しています。
リルトシアスト

@ThomasKwa私が見る限り、インタープリターは実際の正規表現を使用していません。
マーティンエンダー

@マーティンうーん、あなたは正しい。
リルトシアスト

11

Pyth、10 9バイト

qJrz0_XJG

オンラインこのバイオリンを試してみてくださいまたは、一度にすべてのテストケースを確認してください。

説明

qJrz0_XJG
  rz0      Lowercase input
 J         Store a copy in J
     _XJG  Translate J with the reverse alphabet and reverse
q          Compare

3
rz02回使用しているので、変数に保存する方が短くありませんか?
xnor

1
@xnorが示唆するように、q_Jrz0XJG1バイト短くなります。
PurkkaKoodari

6

ジュリア、96バイト

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

これは、文字列を受け入れて文字列を返すラムダ関数です。呼び出すには、変数に割り当てます。

ゴルフをしていない:

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

5

Bash + Linuxユーティリティ、56

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

Truthyの空の文字列とFalseyのようなものを出力します- /dev/fd/63 differ: byte 1, line 1。これが受け入れられない場合-s、追加の3バイトを追加し、成功(Truthy)の場合は0、失敗(Falsey)の場合は1の標準Unixリターンコードを使用できます。


5

網膜、44バイト

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

印刷1または0。バイトカウントは、ファイルがISO 8859-1としてエンコードされていることを前提としています。

オンラインでお試しください!

この答えは、DigitalTraumaのsedの答えに大きく影響されましたが、そもそもこの挑戦に対するアプローチはそれほど多くないと思います。

説明

を見るたびに、コードを行に分割した後にRetinaが最初に行うことは、それらのすべての巡回を改行で置き換えることです。これにより、改行がRetinaのステージセパレーターであっても、1バイトの改行を含めることができます。

$
¶$_

入力を複製することから始めます。入力の終わりを入力と一致させ$、入力自体とともに改行を挿入します(を使用$_)。

T`lL`Ro`.+$

音訳段階。正規表現から始めましょう.+$。入力の2番目のコピーと一致します(一致が文字列の最後まで続くようにすることにより)。したがって、2番目のコピーの文字のみが音訳されます。音訳自体は、いくつかのごく最近の機能を利用しています。lおよびLは、それぞれ小文字と大文字の文字クラスです。o文字変換の他の文字セットを参照し、それをR逆にします。したがって、2つの文字セットは次のように展開されます。

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba

Atbash暗号化の実行中にケースが入れ替わることに気づくでしょうが、いずれにしても大文字と小文字を区別せずに最終比較を行います。

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

次に、2番目のコピーを逆にします。残念ながら、Retinaにはそれを行う便利な方法がまだないため、一度に1つのキャラクターを端から前に移動する必要があります。これは、ラインフィードセパレータを、一部がまだ反転されていないマーカーとして再利用することにより行われます。その部分を一致させますが、最後の文字を個別にキャプチャします。そのキャラクターは前に行き、残りは変わりません。これ+は、Retinaに(ストリングの終わりにあるため)不可能になるまでこれを繰り返し行うように指示します。

i`^(.+)\1$

最後に、2つの文字列が同じかどうかを確認します。これiにより、パターンの大文字と小文字が区別されなくなります。便利なことに、.NETでは、これは後方参照でも大文字と小文字が区別されないことを意味します。元の入力と変更されたコピーの間にセパレータがなくなっていることに気付くかもしれません。ただし、これらは同じ長さであり、文字列が(同じ場合まで)同じ文字列で構成されている場合は、元の文字列と変更された文字列でなければなりません。マーカーとして使用した末尾の改行に何が起こったのか疑問に思っている場合、それはまだありますが、多くの正規表現フレーバーでは、文字が改行の場合、文字列の最後の文字の前に$も一致します。

このステージは1行のみで構成されているため、一致の数をカウントする一致ステージと見なされます。入力がAtbash回文である場合、一致が1つだけ得られ、出力は1です。そうでない場合、この正規表現は一致せず、出力はになります0


改行をステージセパレーターにして、ピルクローをリテラルにする方が、逆の場合よりも優れていると思います。
コナーオブライエン

@CᴏɴᴏʀO'Bʀɪᴇɴ便宜上、エスケープシーケンス、\n 正規表現および$n置換で改行を挿入することもできますが、これはゴルフの無駄なバイトです。;)
マーティン・エンダー

5

GNU Sed、105

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

真実の場合は1、偽の場合は0を出力します。

Retinaでこれを実行しようとしましたが、Atbashの文字変換の前に文字列を保存してからと逆の比較をする方法がわかりませんでした。おそらくもっと良い方法があります。

Sedのy音訳コマンドには、多くの要望があります。


ええ、「保存」することはまだRetinaでは面倒です。文字列を複製してから、1つのコピーのみを音訳して元に戻す必要があります。将来、何らかの分岐/分岐機能を追加したいのですが、詳細についてはまだよくわかりません。
マーティンエンダー

ああ、そうだと思います-前後の文字列をコロンで区切って、似たようなことをしようとしました。私はの終わりに正規表現で倒れたT私はそれが私の理解が正しければ、それははるかに便利です全パターンスペースに適用され、それは順番にそれぞれの文字に適用されると仮定したが、 -
デジタルトラウマ

1
Tの正規表現が入力文字列に適用されます。文字変換は、その正規表現の一致内でのみ実行され、一致しないものはすべて変更されません。正規表現はデフォルトで[\s\S]+省略されているため、すべてを音訳しています。
マーティンエンダー


それのGNU sedのはあるので、あなたが取引でバイトを保存することができます-rにバックスラッシュのフラグを\(して\)yコマンドについては同意します!
トビー・スパイト

4

𝔼𝕊𝕄𝕚𝕟、15文字/ 30バイト

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

Try it here (Firefox only).

説明

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

4

括弧付き、658バイト

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

現在、空白なしのすべての大文字に対してのみ機能します。この修正バージョンのスクリプトを使用して、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'

説明

(
  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
      (() (((()))))
    )
  )
)

4
コードを最長にしたいですか?:P
ゾルガトーネ

4

Pythonの3、90の 85バイト

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

入力を大文字に変換し、大文字のアルファベット範囲にある場合、155からすべての序数を引くことによりAtbashed文字列を計算します。


4

カーフ、73バイト

Kerfは、APL、J、Kと同じ一般的なファミリの独自言語です。暗号化されたコンパクトなonelinerを記述し、明示的なループの使用を避けることができます。

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

ただし、短縮記号の代わりにコマンドのスペルエイリアスを使用し、意味のある識別子を使用すると、プログラムがより明確になり、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]
}

動作中:

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は、特に専用の言語に対して、大量のコードゴルフコンペティションに勝つことはおそらくないでしょうが、APLファミリー言語のアイデアは好きであるが、構文が奇妙すぎると思うなら、いじくり回す価値があります。(免責事項:私はKerfのリファレンスマニュアルの著者です。


3

プロローグ、121バイト

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

これは、入力としてアトムで呼び出されますa('WIZARD').


3

JavaScript(ES6)、91

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

テスト

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>


3

C、101 97バイト

質問ではASCII文字が指定されているため、これは他のエンコーディングを処理しません。

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

説明

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

p文字列の最後から始まるポインタを作成します。我々は、ループ、移動の両方sp互いに向かってs到達端。これは、すべての文字のペアが2回チェックされることを意味しますが、ポインターが交差するとすぐに停止するのに比べて、数バイト節約されます。

繰り返しごとに*p、文字かどうかを確認します。その場合*sは、それが文字の範囲(ASCII 64以上)にあること*pを確認*sし、27(mod 32)まで加算します。64文字を超える文字はこのテストに失敗するため、を確認する必要はありませんisalpha(*s)

*pが文字でない場合、単純にそれがに等しいかどうかをテストし*sます。いずれの場合も、私たちは前にループを終了sしてp渡ります。

場合sp交差している私たちがtrueを返すので、その手紙のすべてのペアは、正しく一致します。そうでない場合はfalseを返します。

テストプログラム

テストする文字列をコマンドライン引数として渡します。これにより、すべてのテストケースに対して正しい出力が生成されます。空の文字列には、要件はありません。私の実装はその入力に対してfalseを返します。

#include <stdio.h>

int main(int argc, char **argv)
{
    while (*++argv)
        printf("\"%s\" => %s\n", *argv, f(*argv)?"true":"false");
    return 0;
}

fK&Rスタイルプロトタイプのの型宣言を削除できますf(char*s)
cat

3

Perl 5、70バイト

サブルーチン:

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

使用中を参照してください。

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


2

CJam、18バイト

qeu_'[,65>_W%erW%=

オンラインで試す

入力を大文字に変換し、文字の変換を実行し、文字列を反転し、等しいかどうかをチェックすることにより機能します。


2

Japt、30 27バイト

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

オンラインでお試しください!

使い方

これは、主にSwap the Alphabetに関するJaptの回答に基づいています。

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

1

Python、156 112バイト

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]

基本的に、大文字の翻訳の辞書を作成し、入力を大文字にします(代わりにすべてが小文字の場合、5バイト追加されます)。次に、大文字で始まる入力の各文字について、文字がアルファベットに含まれていない限り、変換を実行してリストに追加します。その場合、文字はそのまま追加されます。リスト全体に参加して、反転したリストと比較します。

私が前に投稿するつもりだったのとほぼ正確に投稿してくれた@Artyerに叫ぶ。しかし、私は確認する必要があります、これは私の仕事であり、私はこれを独立して行いました

アレックスAによるジュリアの回答に基づいていますここで試してください


の後に不要な空白があり.get(i,i)ます。+1。
Yytsi

1

05AB1E、8バイト(非競合)

この言語は、チャレンジより後の機能を使用しているため、競合していません。

コード:

lDAAR‡RQ

説明:

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

オンラインでお試しください!


1

ファクター、118 113バイト

これは匿名関数です。

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

アルファベットの連想配列を生成するより短い方法を知りません:c


1

Clojure、100バイト

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

(宣言の)約10バイトを削減して、単一の匿名関数に削減することは可能ですが、まだ方法が見つかりませんでした。


1

ルビー、79 77バイト

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

テストする単語をコマンドライン引数として受け入れます。引数がatbash self palindromeである場合はコード0(シェルにとって真実)で終了し、そうでない場合はコード1で終了します。


1
puts結果は3進法で終了するよりも短くなりませんか?

FYIはの$*エイリアスですARGV
ヨルダン

1

ルビー、56バイト

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

これは、文字列を受け取ってtrueor を返す匿名関数falseです。それはかなり不器用です:いくつかのバイトを節約するために、破壊的なバリアントupcase!その後に)を使用します。upcase!残念ながらnil、何も変更されていない場合(すべての数値入力など)は返されるため、それに対処しようとして一部のバイトが失われます。それでも動作します:)


1

MATLAB、61バイト

最短の解決策ではないが、それでも興味深い

f=@(a)~any(changem(upper(a),90:-1:65,65:90)-fliplr(upper(a)))
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.