如果相应字符之间的距离（向上计数）相同，则两个字符串为“凯撒等效项”。是的，我补了这个学期。这是一个例子：

“ Abc”和“ Cde”是等效的，因为

distance from a-c == 2
distance from b-d == 2
distance from c-e == 2

大写字母没有任何区别。

“ Hello”和“ World”不等同于Caesar，因为

distance from h-w == 15
distance from e-o == 10
distance from l-r == 6
distance from l-l == 0
distance from o-d == 15

“ Abcd”和“ Yzab”等同于凯撒，因为

distance from a-y = 24
distance from b-z = 24
distance from c-a = 24 (it wraps around)
distance from d-b = 24

您必须编写一个完整的程序，该程序使用来自STDIN的两个字符串，如果它们等效于凯撒，则输出一个真实值，如果不相同，则输出一个虚假值。

有效输入

• 由于大小写无关紧要，因此只要您的程序中要求输入全部为小写字母，全部为大写字母或所需的任意组合，就可以接受。

• 输入将没有空格或标点符号。

• 输入将具有相同的长度。

Pyth，9个字节

}wm=.rzGG

这两个字符串应以小写字母，换行符分隔。

示范。

怎么运行的：

.r是Pyth的旋转翻译功能。它将第一个自变量中的每个元素从第二个自变量中的第一次出现映射到第二个自变量中的下一个条目。在这种情况下，第二个参数是G小写字母，所以这相当于凯撒偏移量为1。

=在函数前面放置一个使其就位。因此，=.rzG将凯撒（Caesar）偏移量指定为z1 z。请注意，它z已初始化为Pyth中的第一行输入。

该表达式在地图内部使用。m=.rzGG将此转换应用z26次，对的每个元素一次G，并将结果保存在列表中。这给出了所有可能的Caesar移位的列表z。

最后，}w检查输入的下一行是否在该列表中。

CJam，17 12 11字节

Dennis保存了1个字节。

ll.m26f%)-!

在这里测试。

期望第一个字符串为小写，第二个为大写。打印1与凯撒等效的字符串，0否则。

说明

ll           e# Read two lines of input.
  .m         e# Take the differences of corresponding characters.
    26f%     e# Take the differences modulo 26.
        )-   e# Remove all copies of the last difference from the array. This will 
             e# yield an empty array if and only if all differences are the same.
          !  e# Logical NOT, which yields 1 for an empty array and 0 otherwise.

我们要求第一个字符串小写，第二个字符串大写的原因是为了确保差异始终为正。否则，取模可能会返回负数，即使对于凯撒等效字符串也不一定是唯一的。

Python2，68 67 70 69个字节

print len({(ord(y)-ord(x))%26for x,y in zip(*raw_input().split())})<2

Python3，67个 66字节

print(len({(ord(y)-ord(x))%26for x,y in zip(*input().split())})<2)

放开球有点困难，所以只需说明以下内容：

• zip(*raw_input().split())接受输入，将其拆分为两个单词的列表，并假设单词之间用空格隔开。之后，zip使用*运算符将每个单词作为函数的参数传递。该zip函数将为相同位置的字母创建字母对列表。
• (ord(y)-ord(x))%26for x,y in ... 这只是将2个字母的列表转换为这些字母之间的距离的生成器表达式。
• {...} 将这个表达式简化为一组，本质上排除重复项
• len(...)<2 检查集合中是否只剩下一项（对于空字符串，则为0），这实际上意味着所有字母的距离都相同。
• print 输出该值

感谢xnor提醒我set(...)可以替换为，{...}并且for不需要空格。同时还要感谢Josay的<=1to <2优化。

APL（15）

1=≢∪26|-⌿⎕A⍳↑⍞⍞

它需要将字母大写，并打印1或0，如下所示：

      1=≢∪26|-⌿⎕A⍳↑⍞⍞
ABCD
YZAB
1

      1=≢∪26|-⌿⎕A⍳↑⍞⍞
HELLO
WORLD
0

说明：

• ↑⍞⍞：从键盘读取两行，并将字符排列在N×2矩阵中。
• ⎕A⍳：对于每个字符，找到它出现在的位置⎕A（大写字母）。
• -⌿：对于每一列，从第一个值中减去第二个值
• 26|：对每个数字取mod-26。
• 如果字符串与凯撒等效，则此列表中的所有数字现在都相等，因此：
• ≢∪：在列表中找到唯一值的数量
• 1=：与1。

J，19个字节

1=[:#@~.26|-&(3&u:)

同一位置的字母应具有相同的大小写。

在将两个输入字符串转换为它们的代码点表示形式之后，&(3&u:)我们将比较两个数组之差的模26 的小节1长度。如果所有凯撒距离都相同，则将为零。#~.26|-1

用法：

   'abcd' (1=[:#@~.26|-&(3&u:)) 'yzab'
1

在这里在线尝试。

朱莉娅91 87 83字节

a=readline()
b=readline()
show(length(Set([mod(a[i]-b[i],26)for i=1:length(a)]))<2)

取消+说明：

# Read two strings from STDIN
a = readline()
b = readline()

# Get the absolute difference mod 26 of the character values in the strings
x = [mod(a[i] - b[i], 26) for i = 1:length(a)]

# Construct a set consisting of the elements of x. If the set has only a
# single element, the strings are Caesar equivalent. This will print a
# boolean value to STDOUT.
show(length(Set(x)) < 2)

这利用了以下事实：Julia中的字符串可以视为字符数组，并且可以对字符值执行算术运算。只要字符串中每个位置的大小写匹配，输入字符串就可以具有您想要的任何大小写混合形式。

C99，92 个字节，错误   101 92个字节

  r,i;main(z,a)char**a;{for(;z=a[2][++i];)r|=(a[1][i]-z+*a[2]-*a[1]+52)%26;putchar(49-!!r);}

非常简单；假设单词分别作为第一和第二自变量。与编译-std=c99。

Javascript（ES7 Draft），87个字节

要求输入大小写相同。

(p=prompt)(![z=(a[c='charCodeAt'](i)-b[c](i)+26)%26 for(i in b=p(a=p()))].some(x=>x^z))

CJam，13个字节

{r(fm26f%}2*=

它要求每个单词的第一个字符为大写，其他字符为小写。

在这里尝试。（此处为Firefox。）

不幸的是，APL变体不支持字符算术...

说明

{
    r       e# Read a word.
    (f-     e# Return each character value minus the first character.
    26f%    e# Mod 26.
}2*         e# Repeat 2 times.
=           e# Check if they are equal.

Perl，80岁

编辑：失败的优化已滑入高尔夫球场代码。现在，它与非高尔夫版本匹配。（但是字节数是正确的。）

@a=unpack"W*",<>;for(<>=~/./g){$n=ord()-shift@a;$p=!$c++||$p&&$n==$o;$o=$n}say$p

使用Perl版本5.10（perl -M5.10.0或perl -E …）运行say()。略有扩展的版本：

@a=unpack"W*",<>;             # read first string, split and convert to numbers

for(<>=~/./g){                # reads the second string and splits it
   $n=ord()-shift@a;          # convert next character of second string and compare
   $p= !$c++ || $p && $n==$o; # compare differences (special case for first char)
   $o=$n
}

say $p

1如果字符串等效于凯撒，则代码输出（在Perl中为真），如果不是，则输出为空字符串（在Perl中为假）。如果这个解释太松散，我需要为添加2个字节say$p+0，打印1或0。

输入之间的字符大小写必须匹配。

Matlab，49 48字节

这是一个非常快的过程。可悲的是，从stdin获取字符串非常昂贵。

x=@()input('','s');sum(diff(mod(x()-x(),26)))==0

请注意，与大多数（如果不是全部）答案一样，它区分大小写。

编辑：通过定义一个匿名函数减少了一个字节！

Prolog，56个字节

b([],[],_).
b([A|C],[B|D],N):-N is mod(A-B,26),b(C,D,N).

并非支持所有案例组合。

用法

b(`abcd`,`yzab`,_).

在这里在线尝试

C，97字节

#define D (*a[2]++-*a[1]+++26)%26
d,r;main(int c,char**a){for(d=D;*a[1];r|=d-D);puts(r?"N":"Y");}

Scala，57个字节

(readLine zip readLine map(x=>x._1-x._2%26)toSet).size==1

比其他人稍长一点，基本上相等，但是它的语言风格各不相同！

我也有这个版本（56字节）：

(readLine zip readLine map(_._1-x$1._2%26)toSet).size==1

但是我不知道x $ 1的工作是巧合还是设计使然...

Python 2，80个字节

从标准输入中取2个大小写相似的字符串，并用空格隔开：

s,t=raw_input().split();print len(set((ord(c)-ord(d))%26 for c,d in zip(s,t)))<2

在以下测试案例中进行了测试：

tests = [
    ("abc", "abc", True),
    ("abcd", "abc", False),
    ("abc", "cde", True),
    ("Abc", "Cde", True),
    ("abc", "deg", False),
    ("Hello", "World", False),
    ("Abcd", "Yzab", True),
    ("", "", True)
]

for s, t, v in tests:
    if len(s) == len(t): # I didn't read that at first
        assert v == (len(set((ord(c) - ord(d)) % 26 for c, d in zip(s, t))) < 2)

蟒2 - 241 237 188 147个字节

将输入作为小写字符串括在引号中，并以空格分隔。一定有更好的方法..

s=[[ord(x)for x in y]for y in input().split()];v=[];v=[v+[(s[1][i]-s[0][i])%26]for i in xrange(0,len(s[0]))];v=sum(v,[]);print sum(v)//v[0]==len(v)

非高尔夫（260余字节）

strs = [[ord(x) for x in y] for y in raw_input().split()]
vals = []
for i in xrange(0, len(strs[0])):
if strs[0][i]<strs[1][i]:
    vals += [strs[1][i]-strs[0][i]]
else:
    vals += [26-(strs[0][i]-strs[1][i])]
return sum(vals)//vals[0] == len(vals)

R，83 84

与其他解决方案完全相同。将字符串转换为整数向量。将向量的差值修改26。在列表上进行唯一检查，检查长度是否为1。它期望每个字符串中相应字符的大小写相同。

length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2

它等待输入两个字符串

> length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2
abcdefghijklmnopqrstuvwxyz
opqrstuvwxyzabcdefghijklmn
[1] TRUE
> length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2
Hello
World
[1] FALSE
> length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2
Bob
Nan
[1] TRUE
>

Matlab /八度，53 52

x=@()input('','s');isscalar(unique(mod(x()-x(),26)))

输入应全部使用相同的大小写。

可悲的是，Matlab在用户输入方面不是很好。作为匿名句柄，这可能只有35个字节：

@(a,b)isscalar(unique(mod(a-b,26)))

Matlab将字符串的字符视为数字的向量。进行减法可以获取它们的差值，unique并将该向量转换为仅包含唯一值的向量。如果只有一个数字，则这些单词等同于caeser，并且isscalar返回1，否则将返回0。

bash，71 48

使用“标准” Unix程序caesar(6)。

新版本（在@DigitalTrauma的帮助下）：

read a b;seq -f"caesar %g <<<$a" 26|bash|grep $b

• 输入必须在同一行上，并用空格分隔
• 输入之间的字符大小写必须匹配。
• 打印1为true或不打印为false。

如果允许通过命令行参数输入，则可以将其缩短为39个字节：

 seq -f"caesar %g <<<$1" 26|bash|grep $2

记录的旧版本：

 read a b;for i in `seq 26`;do [ `echo $a|caesar $i` = $b ]&&echo 1;done

> <>（鱼），50字节

i:3b*(?v88+0.;n1<
0)?vc1.>~ri-&l?!^i-&:&-2d*%
;n0<

期望处于相同位置的字母具有相同的大小写。

说明

• i:3b*(?v通过88+0.提供循环跳转将第一个单词读入堆栈
• ~ri-&~从堆栈中移除分隔空间，反转堆栈r（第一个字母将在顶部），读取第二个单词的第一个字母i，计算与第一个单词的第一个字母的偏移量，-并将其存储在寄存器中&。
• l?!^i-&:&-2d*%0)?v从堆栈顶部的第一个单词的对应字母中减去第二个单词的每个下一个字母，然后减去&:&-存储在寄存器中的偏移量，并检查结果是否为0 mod 26 2d*%。如果不是，则打印0并终止0n;。c1.提供循环跳转。
• 如果到达第二个单词的末尾，程序将打印1并终止1n;。

KDB（Q），35个字节

{0=sum(1_-':)mod[;26](-)."i"$(x;y)}

说明

                         "i"$(x;y)      / convert to ascii decimal
                     (-).               / get differences
             mod[;26]                   / mod 26
      (1_-':)                           / difference between the differences
 0=sum                                  / sum should be 0 if equivalent
{                                 }     / lambda

测试

q){0=sum(1_-':)mod[;26](-)."i"$(x;y)}["abcd";"yzab"]
1b

Java 281

import java.util.*;enum C{E;Scanner s=new Scanner(System.in);public static void main(String[]z){char[]u=E.n(),v=E.n();int i=0,d=(u[0]-v[0]+26)%26;boolean e=true;for(;++i<u.length;)e&=d==(u[i]-v[i]+26)%26;System.out.print(e);}char[]n(){return s.next().toUpperCase().toCharArray();}}

扩展：

import java.util.*;
enum Caesar{
    Equivalence;
    Scanner input=new Scanner(System.in);
    public static void main(String[]z){
        char[]firstString=Equivalence.nextInput(),secondString=Equivalence.nextInput();
        int index=0,difference=(firstString[0]-secondString[0]+26)%26;
        boolean isEqual=true;
        for(;++index<firstString.length;)
            isEqual&=difference==(firstString[index]-secondString[index]+26)%26;
        System.out.print(isEqual);
    }
    char[]nextInput(){
        return input.next().toUpperCase().toCharArray();
    }
}

如果摆脱了将所有内容都转换为大写的情况，我可以节省14个字节，但是我觉得保留它更完整了。

果冻，5个字节

Oạ/ċ2

在线尝试！

输出等于的正整数，否则输出0

怎么运行的

Oạ/ċ2 - Main link. Argument A (a list of strings)  e.g. ["abc", "cde"]

O     - Ordinal. Cast to code point                     [[97, 98, 99], [99, 100, 101]]
  /   - Reduce the list by...
 ạ    -   absolute difference                           [2, 2, 2]
   ċ2 - Count the number of 2s in the list              3