해당 문자 사이의 거리 (카운트 업)가 동일한 경우 두 문자열은 "시저 동등"입니다. 예,이 용어를 만들었습니다. 예를 들면 다음과 같습니다.

"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"는 Caesar와 동일하므로

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

STDIN에서 두 개의 문자열을 가져와 Caesar와 동등한 경우 정확한 값을 인쇄하고 그렇지 않은 경우 잘못된 값을 인쇄하는 전체 프로그램을 작성해야합니다.

유효한 입력

• 대소 문자는 중요하지 않으므로 프로그램에서 입력이 모두 소문자, 모두 대문자 또는 원하는대로 혼합해야하는 경우 허용됩니다 (답에 명시되어있는 한).

• 입력에 공백이나 문장 부호가 없습니다.

• 입력 길이는 동일합니다.

Pyth, 9 바이트

}wm=.rzGG

두 문자열은 줄 바꿈으로 구분 된 소문자로 예상됩니다.

데모.

작동 방식 :

.rPyth의 회전 변환 기능입니다. 첫 번째 인수의 각 요소를 두 번째 인수의 첫 번째 발생에서 두 번째 인수의 다음 항목에 매핑합니다. 이 경우 두 번째 인수는 G소문자 알파벳이므로 시저 이동 1과 같습니다.

=함수 앞에 놓으면 해당 위치에있게됩니다. 따라서 =.rzG시저 이동을 z1 씩 할당합니다 z. 참고 zPyth 입력에서의 첫 번째 라인에 초기화된다.

이 표현은지도 안에서 사용됩니다. m=.rzGG의 z각 요소에 대해이 변환을 26 회에 적용 G하고 결과를 목록에 저장합니다. 이것은 가능한 모든 시저 이동 목록을 제공합니다 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 ... 이것은 단지 두 글자의 목록을 그 글자들 사이의 거리에 대한 생성기 표현으로 변환합니다.
• {...} 이 표현식을 세트로 줄이고 본질적으로 복제본을 버립니다.
• len(...)<2 세트에 하나의 항목 만 남아 있는지 확인하거나 빈 문자열의 경우 0입니다. 이는 본질적으로 모든 문자의 거리가 동일 함을 의미합니다.
• print 그 값을 출력

xnor 덕분에 나를 set(...)대신 할 수 있으며 {...}이전의 공간 for이 필요하지 않습니다. 또한 <=1to <2최적화에 대한 Josay에게 감사드립니다 .

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

같은 위치에있는 글자는 대소 문자가 같아야합니다.

두 입력 문자열을 코드 포인트 표현으로 변환 한 후 두 배열 의 차이 에 대한 모듈로 (26) 의 너브 길이 와 &(3&u:)비교 합니다. 모든 시저 거리가 동일한 경우 넌브가됩니다 .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.

자바 스크립트 ( ES7 초안 ), 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.

펄, 80

편집 : 실패한 최적화가 골프 코드에 빠져 들었습니다. 이제 ungolfed 버전과 일치합니다. (바이트 수는 맞습니다.)

@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문자열이 Caesar와 같으면 코드가 출력되고 (Perl에서 truthy), 그렇지 않으면 비어있는 문자열 (Perl에서 false)이 출력됩니다. 이 해석을 잃어 너무 경우, 나는 2 바이트를 추가 할 필요가 say$p+0있는 인쇄, 1또는 0.

대소 문자는 입력간에 일치해야합니다.

Matlab, 49 48 바이트

이것은 정말 빠른 것이었다. 슬프게도 stdin에서 문자열을 얻는 것은 꽤 비쌉니다.

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

대부분의 답변과는 달리 대소 문자를 구분합니다.

편집 : 익명 함수를 정의하여 1 바이트를 면도했습니다!

프롤로그, 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");}

스칼라, 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 작업이 우연의 일치인지 아니면 의도적으로인지 모르겠습니다 ...

파이썬 2, 80 바이트

stdin에서 공백으로 구분 된 비슷한 대소 문자 문자열 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생기고 그 벡터를 고유 한 값만 포함하는 벡터로 변환합니다. 하나의 숫자 만있는 경우 단어는 시저와 동일하며 isscalar는 1을 반환하고, 그렇지 않으면 0을 반환합니다.

강타, 71 48

“표준”유닉스 프로그램 사용 caesar(6).

새 버전 (@DigitalTrauma의 많은 도움으로) :

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

• 입력은 공백으로 구분 된 동일한 행에 있어야합니다.
• 대소 문자는 입력간에 일치해야합니다.
• 1true로 인쇄 하거나 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*(?v88+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

자바 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