交换字母

48

在此挑战中，您将“反转”字母或a-z与交换z-a。这通常称为Atbash密码。

因为此转换使输出看起来像某种外语，所以您的代码将需要尽可能短。

例子

abcdefghijklmnopqrstuvwxyz
zyxwvutsrqponmlkjihgfedcba

Programming Puzzles & Code Golf
Kiltiznnrmt Kfaaovh & Xlwv Tlou

Hello, World!
Svool, Dliow!

规格

  • 输入可能包含多行，并且只能是ASCII码
  • 没有 额外的空格应该被添加到输出
  • 案件必须保留

排行榜

显示代码段

这是代码高尔夫球，因此以字节为单位的最短代码获胜

code-golf  string 
— 下山羊
source
24
为理由+1 “由于此转换使输出看起来像某种外语，因此您的代码将需要尽可能短。”
— 猫
11
琐事：这是Atbash，与圣经一样古老。
— 雅各布
6
“由于这种转换使输出看起来像某种外语，因此您的代码将需要尽可能短。” 那是什么样的逻辑？因为您的描述所引起的问号与使​​用某种外语书写的问号一样多，所以您对这个问题的答案应该使用可理解的自然语言，并且会有些冗长。
— 巴特
Kiltiznnrmt Kfaaovh和Xlwv Tlou应该是“编程琐事和保龄球节目”的新网站...
— Erik the Outgolfer
您为什么不允许额外的空格？这使得在某些总是带有尾随换行符的语言中变得不可能。我看不到它给挑战增加了任何东西。
— 硕果累累

Answers:

11

Pyth，8个字节

XXzG)rG1

@xnor在@FryAmTheEggman的Pyth答案中建议了这种更简单的方法，然后将其翻译为Pyth。

X仅给定两个参数时，它使用（translate）的方便行为：它将第二个参数转换为第二个参数的反向。我们首先使用小写字母（G），然后使用大写字母G。

— 小鱼
source
16

C，59个字节

很抱歉再次启动C，但是我对只看到C 函数感到有些失望。我的印象是OP在寻找可用的产品。

main(c){while(~(c=getchar()))putchar(isalpha(c)?c+4^31:c);}

在Ubuntu 14.04上通过以下简单方式进行编译：

cc swalpha.c

生成的可执行文件从stdin读取任何数量的行，并将结果写入stdout。

感谢其他许多XOR技巧的发布者。

— 鲁德·海尔德曼
source
11

CJam，17个字节

我想帮助GamrCorps打他的CJam解决方案，但结果却截然不同，因此我决定单独回答。

q'[,_el^_W%32f^er

在线尝试。

说明

q     e# Read all input.
'[,   e# Get a character range from the null byte up to and including "Z".
_el   e# Duplicate and convert to lowercase.
^     e# Symmetric set difference. Due to the lowercase operation only letters will not
      e# appear in both sets, and so we get a string with all uppercase letters followed
      e# by all lowercase letters, i.e "ABC...XYZabc...xyz".
_W%   e# Duplicate and reverse. Gives: "zyx...cbaZYX...CBA".
32f^  e# Take each character XOR 32 which swaps the case, so now we have:
      e#                               "ZYX...CBAzyx...cba"
er    e# Transliterate: substitute each character in the first string with the correspoding
      e# character in the second string.
— 马丁·恩德
source
4
好吧，很高兴您能提供帮助！那就是我试图做出的解决方案，我只是想不出XOR。不错的工作！
— GamrCorps
1
SE的语法突出显示讨厌esolangs。
— Cyoce
@Cyoce他们可能没有时间。考虑到该网站上有多少种语言。就是说，CJam可能是更容易使用的一种，因为它不是自动修改的，并且结构非常清晰。我希望看到他们尝试将语法突出显示添加到///这样的自我修改语言中。
— 硕果累累
@ Challenger5 afaik，突出显示的语法仅使用Google的美化功能，必须在其中添加对各种esolang的支持。
— 马丁·恩德
11

JavaScript（ES6），69 67字节

x=>x.replace(/[A-Z]/gi,c=>String.fromCharCode(c.charCodeAt()+4^31))

使用与我的Japt答案相同的策略：

x=>x.replace(/[A-Z]/gi,C=>   // Replace each letter C with
 String.fromCharCode(        //  the character with char code
  C.charCodeAt()+4^31))      //   the char code of C, plus 4, with the last 5 bits flipped.

诅咒您令人难以置信的长属性名称，JS ...

— ETH生产
source
1
+1表示JS的冗长属性名称。我最喜欢的仍然是臭名昭著的document.getElementById
— Cyoce
2
@Cyoce试试，document.getElementsByClassName或者在Firefox和Chrome上document.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC
— Ismael Miguel
这似乎只有66个字节，而不是67个
— Downgoat '16
@Doᴡɴɢᴏᴀᴛ你说得对，谢谢！
— ETHproductions 2016年
好像您在打高尔夫球的代码的末尾缺少一个右括号。
— starbeamrainbowlabs
10

视网膜，17 14 13字节

码：

\T`w`_dZ-Az-a

说明：

\             # This suppresses the trailing linefeed
 T            # Switches to transliterate mode
  `w          # w is short for _0-9A-Za-z
    `_d       # d is short for 0-9
       Z-Az-a # Z-Az-a

这样可以完成一些魔术工作并完成任务。

在这里尝试。

— 阿德南
source
2
幸运的是我最近添加了\。不幸的是，我还没有为字母添加字符类和反转字符类。
— Martin Ender'1
@MartinBüttner确实非常幸运，这几乎使我的回答无效:)
— Adnan
作为参考，从Retina 0.7.2开始，您可以这样做\T`lL`RlRL。
— Martin Ender'1
9

珀斯10 9

uXGr;H)2z

感谢Jakube使用;！的新功能节省了一个字节！

测试套件

快速说明：从数字0和1的输入开始减少。要执行的操作是分别使用python中的上，下函数r...0或r...1分别转换小写字母，然后将其应用于python，然后反转。

— 弗莱姆·埃格曼
source
1
9个字节归功于一项新功能（甚至还没有一天使用）：uXGr;H)2z
— Jakube's
5
您能补充说明吗？
— TanMath
1
您不能同时使用X字母和大写字母吗？
— xnor
1
@xnor XXzG)rG1吗？这似乎有效。
— lirtosiast
或者，也许将小写字母和大写字母上的X连接在一起，然后交换大小写吗？实际上，那可能更长。
— xnor
6

朱莉娅74 61 47字节

s->replace(s,r"[a-z]"i,t->Char(31$Int(t[1])-4))

这是一个lambda函数，它接受一个字符串并返回一个字符串。要调用它，请将其分配给变量。

我们使用正则表达式匹配每个字母，并将每个字母替换为对应于该字母的ASCII码减去31或31的ASCII字符。

— 亚历克斯·A
source
哇，这很优雅 我收到了弃用警告，$因此您可能需要将其更新为⊻。不知道您可以在中使用函数replace。
— niczky12
5

C，150个 129字节

void rev(char*s){int i,t;for(i=0;i<strlen(s);i++){t=s[i]+25;t=t<116?180-t:244-t;isalpha(s[i])?printf("%c",t):printf("%c",s[i]);}}

此函数仅将char转换为int并在打印之前将适当的偏移量添加到int。我知道它不是最短的，但是我没有看到C实现。

用法示例

#include<stdio.h>
#include<string.h>
#include<ctype.h>

void rev(char*s){int i,temp;for(i=0;i<strlen(s);i++){temp=s[i]+25;temp=temp<116?180-temp:244-temp;isalpha(s[i])?printf("%c",temp):printf("%c",s[i]);}}


int main(){
   char *s = "hello, there";
   rev(s);
   return 0;
}

更新：缩短了变量名称。

— 丹瓦基姆
source
欢迎来到编程难题和Code Golf Stack Exchange！这是一个非常好的方法。通过使所有变量（包括temp）恰好一个字符长，可以进行更多的操作。
— wizzwizz4 2016年
啊，你是对的！我会regolf这一个
— Danwakeem
1
您认为您可以接受我的挑战吗？分析您的椅子
— wizzwizz4'1
1
是的，它可以在没有标头的情况下工作，您只会收到编译器警告@ edc65我认为，因为它可以编译并运行，因此不会被认为是作弊行为，但在实际使用中，您应始终包含标头。
— Danwakeem
1
107个字节：i,t;r(char*s){for(;i<strlen(s);i++){t=s[i]+25;t=t<116?180-t:244-t;isalpha(s[i])?putchar(t):putchar(s[i]);}}
— Spikatrix
5

Japt，23 22字节

Ur"[A-Za-z]"_c +4^31 d

在线尝试！

这个怎么运作

Ur"[A-Za-z]"_  // Take the input and replace each letter with:
 c +4          //  Take its char code and add 4. This results in
               //  the string      "ABC...XYZabc...xyz"
               //  becoming        "EFG...\]^efg...|}~".
 ^31           //  XOR the result by 31. This flips its last five 5 bits.
               //  We now have     "ZYX...CBAzyx...cba".
 d             //  Convert back from a char code.
               // Implicit: output last expression
— ETH生产
source
对此使用XOR的好主意（我借来的...）
— Luis Mendo
5

C，64

一个空函数，用于修改字符串。

t(char*p){for(int c;c=*p;)*p++=c>64&c<91|c>96&c<123?(c^31)-4:c;}

测试：ideone

— edc65
source
1
c;t(char*p){for(;c=*p;)*p++=c>64&c<91|c>96&c<123?(c^31)-4:c;}
— Spikatrix '16
@CoolGuy对，但是我不喜欢函数中的全局变量……只是我
— edc65
这不是64个字节吗？
— Downgoat
@Doᴡɴɢᴏᴀᴛ是的，这是..谢谢..
— edc65
5

R，69 61字节

感谢@Giuseppe削减了一些额外的字节：

function(s)cat(chartr("a-zA-Z",intToUtf8(c(122:97,90:65)),s))

先前版本：

function(s)cat(chartr("a-zA-Z",rawToChar(as.raw(c(122:97,90:65))),s))

这是一个匿名函数。用法：

> f=function(s)cat(chartr("a-zA-Z",rawToChar(as.raw(c(122:97,90:65))),s))
> f("Hello, World!")
Svool, Dliow!
> f("Programming Puzzles & Code Golf")
Kiltiznnrmt Kfaaovh & Xlwv Tlou
> f("This is
+ a multiline
+ example.")
Gsrh rh
z nfogrormv
vcznkov.
— 浮游动物
source
1
intToUtf8(c(122:97,90:65))而不是raw转化，您也可以摆脱转化cat。我养成高尔夫的习惯，这是您1岁以上的答案……
— Giuseppe
4

严重的是，31个字节（非竞争）

úúû+╗úRúûR+╝,`;╜íuWD╛E(X0WX`Mεj

十六进制转储：

a3a3962bbba352a396522bbc2c603bbda1755744be452858305758604dee6a

在线试用

说明：

úúû+╗                             Put UPPERCASElowercase in reg0
     úRúûR+╝                      Put ESACREPPUesacrewol in reg1
            ,                     Fetch input.
             `             `Mεj   Map over the characters in string as list, joining result
              ;╜íu                Find 1-index of character in UPPERCASElowercase
                  W     0WX       If it is positive (present): 
                   D              Convert back to 0-index
                    ╛E            Look it up in ESACREPPUesacrewol
                      (X          Delete the original character.
                                  (Else just leave the original character unchanged.)

我只是意识到该规范说没有额外的空格，但是没有办法抑制在认真输出中尾随换行符，因此没有认真解决方案。

— 昆托
source
1
什么ESACREPPUesacrewol意思
— Downgoat
3
@Doᴡɴɢᴏᴀᴛ大写字母颠倒了小写字母颠倒了
— Mama Fun
2
反转的大写字母之前为反转的小写字母
— quintopia'1
4

Ruby，40个字节

新的解决方案：从这里的其他一些帖子中偷来一点魔术：

->s{s.gsub(/[a-z]/i){($&.ord+4^31).chr}}

Ruby，55 46字节

->s{s.tr'a-zA-Z',[*?A..?Z,*?a..?z].reverse*''}

@manatwork节省了9个字节

测试运行：

->s{s.gsub(/[a-z]/i){($&.ord+4^31).chr}}["Kiltiznnrmt Kfaaovh & Xlwv Tlou"]
=> "Programming Puzzles & Code Golf"
— 达涅罗
source
3

𝔼𝕊𝕄𝕚𝕟2，12个字符/ 26个字节（非竞争性）

ïĪ(ᶐ+ᶛ,ᶐᴙ+ᶛᴙ

Try it here (Firefox only).

发布挑战后添加了音译功能。

说明

ïĪ(ᶐ+ᶛ,ᶐᴙ+ᶛᴙ // implicit: ï=input
ïĪ(           // transliterate ï...
   ᶐ+ᶛ,       // from uppercase+lowercase alphabet...
       ᶐᴙ+ᶛᴙ  // ... to reversed uppercase+reversed lowercase alphabet
              // implicit output
— 妈妈趣味卷
source
我以为𝔼𝕊𝕄𝕚𝕟2将被称为𝔼𝕊∞？
— Downgoat's
1
不，我决定将其保存为𝔼𝕊𝕄𝕚𝕟的补充（但不同）语言。
— Mama Fun Roll'Roll''Jan
IIRC有一个黑板大胆的2
— 康纳尔奥布莱恩
@ՊՓԼՃՐՊՃՈԲՍԼ将其称为ESMax（双击）。
— mbomb007 '16
3

CJam，21个字节

q'[,65>__el_@+W%@@+er

并非最佳解决方案...尚可... 在线尝试

不对事物进行分组就很难解释，因此这里是一个一般性的解释：获取输入，两次按大写字母和两次小写字母，旋转事物，组合大写和小写字符串，反转一个并使用音译（类似于Retina答案）。

— GamrCorps
source
这会输出尾随换行符吗？
— LegionMammal978 '16
@ LegionMammal978除非aditsu更改了堆栈的输出方式，否则不应该这样做。
— GamrCorps，2016年
@ LegionMammal978我没有。
— Martin Ender'1
3

PostgreSQL，118125字节

SELECT s,TRANSLATE(s,t||UPPER(t),REVERSE(t)||REVERSE(UPPER(t)))
FROM(SELECT text'Programming Puzzles & Code Golf's,text'abcdefghijklmnopqrstuvwxyz't)r

SqlFiddleDemo

输出：

╔══════════════════════════════════╦═════════════════════════════════╗
║                s                 ║            translate            ║
╠══════════════════════════════════╬═════════════════════════════════╣
║ Programming Puzzles & Code Golf  ║ Kiltiznnrmt Kfaaovh & Xlwv Tlou ║
╚══════════════════════════════════╩═════════════════════════════════╝

输入： SELECT text'...'s

编辑：

输入为表格：

SELECT s,TRANSLATE(s,t||UPPER(t),REVERSE(t)||REVERSE(UPPER(t)))
FROM i,(SELECT text'abcdefghijklmnopqrstuvwxyz't)r
GROUP BY s,t

SqlFiddleDemo

输出：

╔══════════════════════════════════╦═════════════════════════════════╗
║                s                 ║            translate            ║
╠══════════════════════════════════╬═════════════════════════════════╣
║ Hello, World!                    ║ Svool, Dliow!                   ║
║ Programming Puzzles & Code Golf  ║ Kiltiznnrmt Kfaaovh & Xlwv Tlou ║
║ abcdefghijklmnopqrstuvwxyz       ║ zyxwvutsrqponmlkjihgfedcba      ║
╚══════════════════════════════════╩═════════════════════════════════╝
— lad2025
source
嗨，lad2025，我认为这比118短，但我不是计数规则方面的专家
— t-clausen.dk
2

Python 3中，195个 169 168 166字节

感谢@TrangOul -2个字节！

我怎么没看到以前可以打高尔夫球呢？ 

x=__import__('string').ascii_letters;y,z=x[26:],x[:26];a,b=y[::-1],z[::-1];print(''.join(b[z.index(i)]if i in b else a[y.index(i)]if i in a else i for i in input()))

（sorta）取消高尔夫：

x = __import__('string').ascii_letters;
y, z = x[26: ], x[: 26];
a, b = y[::-1], z[::-1];
print(''.join(b[z.index(i)]
    if i in b
    else a[y.index(i)]
    if i in a
    else i
    for i in input()
))

在Ideone上尝试！

— 猫
source
1
您可以通过删除最节省2个字节[]的join。
— Trang Oul
@TrangOul真的吗？这是一个列表理解，所以我认为它必须是列表，否则您会得到它generator object <genexpr> at...，但我将对其进行测试
— 2016年
@TrangOul没关系，我学到了一些东西，谢谢！
— 猫
任何可迭代的[包含str值]都可以传递给join()函数。
— 董里（Trang Oul）
2

Python，61个字节

lambda x:''.join([c,chr(ord(c)+4^31)][c.isalpha()]for c in x)

匿名函数。在字母上，通过加4，然后翻转最后五个位来对位表示进行反转操作，类似于ETHproductions的Javascript Answer。

— 异或
source
刚写了完全一样的东西哈哈
— sagiksp
2

Haskell，119 104字节

@nimi节省了15个字节。 

c=fromEnum;s=toEnum;f[]="";f(x:y)|64<c x&&c x<91=s(155-c x):f y|96<c x&&c x<123=s(219-c x):f y|0<1=x:f y

用法：

f "abcdefghijklmnopqrstuvwxyz"
"zyxwvutsrqponmlkjihgfedcba"

f "Programming Puzzles & Code Golf"
"Kiltiznnrmt Kfaaovh & Xlwv Tlou"

f "Hello, World!"
"Svool, Dliow!"

说明 

let c=fromEnum;s=toEnum;--wrap names for later use, fromEnum gets ascii code from char, toEnum gets char from ascii code
f[]=[];                 --feed empty list (of chars in this case), get empty list
f(x:y)                  --feed a list, separate the first element and...
|64<c x&&c x<91=        --if its an uppercase char (using ascii code range)...
s(c x*(-1)+155)         --  inverse its ascii code value, move it to the range of uppercase and get the new char
                        --  (like rotating half turn a ruler by the side and then sliding it to the space it previously occupied)
:f y                    --  feed the rest of the list and stick the new char in front of the result
|96<c x&&c x<123=       --if its a lowercase char (using ascii code range)...
s(c x*(-1)+219)         --  inverse its ascii code value, move it to the range of lowercase and get the new char
:f y                    --  feed the rest of the list and stick the new char in front of the result
|True=x:f y             --otherwise feed the rest of the list and stick the char in front of the result

我是Haskell的新手...函数编程...以及该站点，我知道这个问题有（很多）更好的答案，但请耐心等待。

— 蓬松的耳朵
source
打高尔夫球的一些技巧：a）无需使用let。直接从开始c=fromEnum。使用(155-c x)和(219-c x)。c）True可以替换为1<2。-代码无法为我加载函数c和s（ghci 7.10.2）的“歧义类型变量”错误，但可以使用f[]=""代替轻松解决f[]=[]。
— nimi 2016年
谢谢！，我实际上想知道如果不带“ let”，它是否有效，因为它不直接在GHC上运行。
— 蓬松的耳朵
2

Perl 6，28个字节

{S:g/\w/{chr $/.ord+4+^31}/}

用法：

# give it a lexical name
my &swap = { … }

say swap 'Programming Puzzles & Code Golf';
# Kiltiznnrmt Kfaaovh & Xlwv Tlou

say swap ('a'..'z').join
# zyxwvutsrqponmlkjihgfedcba
— 布拉德·吉尔伯特b2gills
source
当我运行它时，它说：Warning: Use of "ord" without parentheses is ambiguous at (eval 8)[/System/Library/Perl/5.18/perl5db.pl:732] line 2.我对perl一无所知，所以我做错了什么吗？我将如何运行？
— Downgoat
@Doᴡɴɢᴏᴀᴛ如果您注意到它说这是用Perl 6编写的，则可以在freenode上转到＃perl6并键入m: my &swap = {S:g/\w/{chr $/.ord+4+^31}/}; say swap ('a'..'z').join
— Brad Gilbert b2gills
啊，好的，显然我看不懂：P
— Downgoat
@Doᴡɴɢᴏᴀᴛ我添加了一条注释，您可以在freenode的＃perl6上对其进行测试
— Brad Gilbert b2gills
2

Java，136个字节

void x(String i){for(char c:i.toCharArray()){if(Character.isLetter(c))c=c<91?(char)(90-(c-65)):(char)(122-(c-97));System.out.print(c);}}

用法示例：

class Test {
  static void x(String i){for(char c:i.toCharArray()){if(Character.isLetter(c))c=c<91?(char)(90-(c-65)):(char)(122-(c-97));System.out.print(c);}}
  public static void main(String[] args) {
    x("Programming Puzzles & Code Golf");
    // produces "Kiltiznnrmt Kfaaovh & Xlwv Tlou"
  }
}

就字节大小而言，可能是最差的常用语言。

— 肖恩
source
1
— Downgoat
我知道这是在1.5年前发布的，但是您可以打高尔夫，例如：void x(String i){for(Character c:i.toCharArray())System.out.print(c.isLetter(c)?(char)(c<91?90-(c-65):122-(c-97)):c);}（118字节）
— Kevin Cruijssen
或更短的时间：（116个字节）void y(String i){for(int c:i.getBytes())System.out.print((char)(c>65&c<91|c>96&c<123?c<91?90-(c-65):122-(c-97):c));}
— 凯文·克鲁伊森
1
@KevinCruijssen您还可以重新排列计算，以使90-(c-65)成为-c+65+90 和122-(‌​c-97)成为否，从而不需要括号，-c+97+122每个括号都节省一个字节。
— Zavada
2

Unix shell + tr + printf，35个字节

tr A-Za-z `printf %s {Z..A} {z..a}`

这是tr中的一个典型答案。我想怎么可能是问题音译字母去无规范的答案TR ansliterate字母？

tr本身甚至都不做“ Hello，World！” 因为它不是编程语言，所以我将答案标记为非竞争性[1]。

[1]：编辑：实际上，Unix shell是语言，tr是标准库。感谢Downgoat和Digital Trauma帮助我发现了这一点。

— 用户名
source
3
我认为可以将Shell或bash声明为一种语言，而将通用实用程序（tr在coreutils中）声明为标准库。看到无数我的回答;-)
— 数字创伤
1
但这不起作用：tr: range-endpoints of 'Z-A' are in reverse collating sequence order。我认为您必须做类似的事情tr A-Za-z $(printf %s {Z..A} {z..a})（并替换$( )为反引号）
— Digital Trauma
@DigitalTrauma但不是每个人的系统上都有printf。
— user48538
7
我认为您很难找到一个没有的Unix系统，printf毕竟它是Posix指定的。而且它的内置bash如今已经无处不在。无论如何，在每个人的系统上预装一些东西并不是代码高尔夫的前提-也不是每个人的系统上都有CJam ;-)
— Digital Trauma
1
之间的空间}和{需要-否则的扩张变得像Zz Zy Zx ... Za Yz ... Aa
— 数字创伤
1

MATL，21 28字节

使用版本6.0.0，它早于此挑战。该代码在Octave中运行。

jttk2Y2mXK)o31Z~4-cK(

例

>> matl
 > jttk2Y2mXK)o31Z~4-cK(
 >
> Hello, World!
Svool, Dliow!

说明

j             % input string
t             % duplicate
tk            % duplicate and convert to lowercase
2Y2           % string 'abc...xyz'
m             % "ismember" function: produces logical index of letter positions
XK            % copy to clipboard K
)             % index into string to get its letters
o31Z~4-       % bitwise XOR with 31 and subtract 4
c             % convert to char
K             % paste logical index from clipboard K
(             % put back modified letters into original string

旧方法，28字节

j1Y2!tkh"t@2#m@0v27b-)wXK)K(
— 路易斯·门多
source
1

MATLAB，61字节

@(x)[abs(-x+ismember(x,65:90)*155+ismember(x,97:122)*219),'']

我试过了f=@ismember，然后将范围a=65:90设为变量，然后32+a在第二步ismember设为调用中执行。所有这些都缩短了代码，但是会导致一个程序，因此需要disp和input。

这给出：

ans('Hello, World!')
ans =
Svool, Dliow!

ans('Programming Puzzles & Code Golf')
ans =
Kiltiznnrmt Kfaaovh & Xlwv Tlou
— 斯蒂夫·格里芬
source
1

Brachylog，66位元组

_|hH(:64>:91<,77-H+78=X;H:96>:123<,109-H+110=X;HX),[X]:"~c"w,?b:0&

这里缺少内置功能确实很痛苦，因此我们必须求助于旧的ASCII代码计算。

谓词 brachylog_main期望将字符串作为输入而没有输出，例如brachylog_main(`Hello, World!`,_).

说明

_                                                                  § If the input is empty,
                                                                   § return true
                                                                   §
 |                                                                 § Else
                                                                   §
  hH(                                            ),[X]:"~c"w       § Print variable X which
                                                                   § depends on the head of
                                                                   § the input as a char code
                                                                   §
                                                            ,?b:0& § Recursive call on the
                                                                   § tail of the input
                                                                   §
     :64>:91<,77-H+78=X                                            § If H is capital, X =
                                                                   § 77 - H + 78
                       ;                                           § Else if H is non-cap, X=
                        H:96>:123<,109-H+110=X                     § 109 - H + 110
                                              ;                    § Else (not a letter)
                                               HX                  § H = X
— 致命
source
1

Perl 6中，40 39个字节

由于其他所有人都在执行匿名功能：

my &f=*.trans(/\w/=>{chr $/.ord+4+^31})

（感谢@ b2gills的提示）

与其他一些帖子一样使用伏都教。我不确定是否在字节数中包含变量/函数声明，所以我以防万一。没有它，此解决方案只有34个字节。

用法：

> f "zyxwvutsrqponmlkjihgfedcba"
abcdefghijklmnopqrstuvwxyz
> f "Kiltiznnrmt Kfaaovh & Xlwv Tlou"
Programming Puzzles & Code Golf
> f "Svool, Dliow!"
Hello, World!
— 热键
source
您可以使用*.trans(…)它来使其更短。
— 布拉德·吉尔伯特b2gills '16
1

Python 3中，164个 159字节

def f(t,a="abcdefghijklmnopqrstuvwxyz",b=""):
 for c in t:u=64<ord(c)<91;c=c.lower();c=a[::-1][a.index(c)] if c in a else c;b+=c.upper() if u else c
 return b
— ArgenisGarcía
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.