Zwei Zeichenfolgen sind "Caesar-Äquivalent", wenn der Abstand (Aufwärtszählen) zwischen den entsprechenden Zeichen gleich ist. Ja, ich habe diesen Begriff erfunden. Hier ist ein Beispiel:

"Abc" und "Cde" sind gleichbedeutend damit

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

Die Großschreibung macht keinen Unterschied.

"Hallo" und "Welt" sind da nicht gleichbedeutend mit 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" und "Yzab" sind Caesar-Äquivalent, weil

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

Sie müssen ein vollständiges Programm schreiben, das zwei Zeichenfolgen aus STDIN entnimmt und einen Wahrheitswert ausgibt, wenn diese Caesar-Äquivalent sind, und einen falschen Wert, wenn sie nicht sind.

Gültige Eingabe

• Da die Groß- und Kleinschreibung keine Rolle spielt, ist es akzeptabel, wenn für Ihr Programm die Eingabe nur in Kleinbuchstaben, in Großbuchstaben oder in einer beliebigen Mischung erfolgen muss, sofern dies in Ihrer Antwort angegeben ist.

• Die Eingabe enthält keine Leerzeichen oder Satzzeichen.

• Die Eingaben sind gleich lang.

Pyth, 9 Bytes

}wm=.rzGG

Es wird erwartet, dass die beiden Zeichenfolgen in Kleinbuchstaben und durch Zeilenumbrüche getrennt sind.

Demonstration.

Wie es funktioniert:

.rist die Drehübersetzungsfunktion von Pyth. Es ordnet jedes Element im ersten Argument von seinem ersten Vorkommen im zweiten Argument bis zum nächsten Eintrag im zweiten Argument zu. In diesem Fall ist das zweite Argument Gdas Kleinbuchstaben-Alphabet. Dies entspricht also einer Caesar-Verschiebung von 1.

Wenn Sie =der Funktion eine voranstellen, wird sie eingefügt. Damit =.rzGordnet Caesar die Verschiebung zum eins zu z. Beachten Sie, dass zin Pyth die erste Eingabezeile initialisiert wird.

Dieser Ausdruck wird in einer Karte verwendet. m=.rzGGWendet diese Transformation z26 Mal für jedes Element von Gan und speichert die Ergebnisse in einer Liste. Dies gibt die Liste aller möglichen Caesar-Verschiebungen von z.

Prüft }wabschließend, ob sich die nächste Eingabezeile in dieser Liste befindet.

CJam, 17 12 11 Bytes

1 Byte von Dennis gespeichert.

ll.m26f%)-!

Teste es hier.

Erwartet, dass die erste Zeichenfolge in Kleinbuchstaben und die zweite in Großbuchstaben geschrieben wird. Drucke 1für Caesar-äquivalente Zeichenfolgen und 0andere.

Erläuterung

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.

Der Grund, warum wir die erste Zeichenfolge in Kleinbuchstaben und die zweite in Großbuchstaben benötigen, besteht darin, sicherzustellen, dass die Differenz immer positiv ist. Andernfalls könnte das Modulo etwas Negatives zurückgeben und wäre selbst für Caesar-äquivalente Saiten nicht unbedingt eindeutig.

Python2, 68 67 70 69 Bytes

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

Python3, 67 66 Bytes

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

Es ist ein bisschen schwer, Golf zu spielen, also erkläre einfach die Teile:

• zip(*raw_input().split())Nimmt die Eingabe und teilt sie in eine Liste mit zwei Wörtern auf, vorausgesetzt, Wörter werden durch Leerzeichen getrennt. Danach wird jedes Wort zipunter Verwendung des *Operators als Parameter der Funktion übergeben . Die zipFunktion erstellt eine Liste von Buchstabenpaaren für Buchstaben an derselben Position.
• (ord(y)-ord(x))%26for x,y in ... Dies transformiert nur die Liste von 2 Buchstaben in einen Generatorausdruck der Abstände zwischen diesen Buchstaben.
• {...} reduziert diesen Ausdruck auf eine Menge und wirft im Wesentlichen Duplikate aus
• len(...)<2 prüft, ob nur noch ein Element in der Menge vorhanden ist (oder 0 für leere Zeichenfolgen), was im Wesentlichen bedeutet, dass alle Buchstaben den gleichen Abstand hatten.
• print gibt diesen Wert aus

Dank xnor für die Erinnerung set(...)kann ich mit ersetzt werden {...}und der Platz davor forwird nicht benötigt. Auch dank Josay für die <=1zur <2Optimierung.

APL (15)

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

Die Buchstaben müssen in Großbuchstaben geschrieben sein und werden entweder 1oder 0wie folgt gedruckt :

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

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

Erläuterung:

• ↑⍞⍞: Lesen Sie zwei Zeilen von der Tastatur und ordnen Sie die Zeichen in einer N × 2-Matrix an.
• ⎕A⍳: Finden Sie für jedes Zeichen, an welcher Position es vorkommt ⎕A(Großbuchstaben).
• -⌿: Subtrahieren Sie für jede Spalte den zweiten Wert vom ersten Wert
• 26|: nimm den Mod-26 jeder dieser Nummern.
• Wenn die Zeichenfolgen Caesar-äquivalent sind, sind jetzt alle Zahlen in dieser Liste gleich.
• ≢∪: Finden Sie die Anzahl der eindeutigen Werte in der Liste
• 1=: Vergleichen Sie das mit 1.

J, 19 Bytes

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

Briefe an derselben Position sollten die gleiche Groß- und Kleinschreibung haben.

Nachdem &(3&u:)wir beide Eingabezeichenfolgen in ihre Codepunktdarstellung konvertiert haben, vergleichen wir 1mit der Länge #des Nubs ~.des Modulo 26 26|die Differenz -der beiden Arrays. Der Knoten wird sein, 1wenn alle Caesar-Abstände gleich sind.

Verwendung:

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

Probieren Sie es hier online aus.

Julia, 91 87 83 Bytes

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

Ungolfed + Erklärung:

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

Dies nutzt die Tatsache aus, dass Zeichenfolgen in Julia als Zeichenarrays behandelt werden können und dass arithmetische Operationen für Zeichenwerte ausgeführt werden können. Die Eingabezeichenfolgen können eine beliebige Mischung aus Groß- und Kleinschreibung aufweisen, sofern die Groß- und Kleinschreibung an jeder Position zwischen den Zeichenfolgen übereinstimmt.

C99, 92 Bytes mit Fehler   101, 92 Bytes

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

Ziemlich einfach; Nimmt an, dass Wörter als erstes bzw. zweites Argument kommen. Kompiliert mit -std=c99.

Javascript ( ES7-Entwurf ), 87 Byte

Erfordert, dass die Eingaben dem gleichen Fall entsprechen.

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

{r(fm26f%}2*=

Das erste Zeichen in jedem Wort muss in Großbuchstaben geschrieben werden, andere in Kleinbuchstaben.

Probieren Sie es hier aus . ( Firefox hier .)

Schade, dass die APL-Varianten keine Zeichenarithmetik unterstützen ...

Erläuterung

{
    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

Bearbeiten : Eine fehlgeschlagene Optimierung war in den Golfcode gerutscht. Jetzt passt es zur ungolften Version. (Die Anzahl der Bytes war jedoch korrekt.)

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

Führen Sie mit Perl Version 5.10 ( perl -M5.10.0oder perl -E …) für say(). Leicht erweiterte Version:

@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

Der Code gibt 1(wahrheitsgemäß in Perl) aus, wenn die Zeichenfolgen Caesar-äquivalent sind, und die leere Zeichenfolge (falsch in Perl), wenn dies nicht der Fall ist. Wenn dies eine zu lose Interpretation ist, muss ich 2 Bytes hinzufügen, für say$p+0die 1oder gedruckt wird 0.

Die Groß- und Kleinschreibung muss zwischen den Eingaben übereinstimmen.

Matlab, 49 48 Bytes

Das war sehr schnell. Leider ist es ziemlich teuer, eine Saite von stdin zu bekommen.

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

Beachten Sie, dass wie bei den meisten Antworten zwischen Groß- und Kleinschreibung unterschieden wird.

BEARBEITEN: ein Byte durch Definition einer anonymen Funktion abgeschnitten!

Prolog, 56 Bytes

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

Es werden nicht alle Fallkombinationen unterstützt.

Verwendung

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

Probieren Sie es hier online aus

C 97 Bytes

#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 Bytes

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

Etwas länger als die anderen und im Wesentlichen gleichwertig, aber es ist in einer unterschiedlichen Art der Sprache!

Ich habe auch diese Version (56 Bytes):

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

Aber ich weiß nicht, ob die Funktion von x $ 1 zufällig oder beabsichtigt ist ...

Python 2, 80 Bytes

Nimmt 2 ähnlich umhüllte Saiten von stdin, die durch ein Leerzeichen getrennt sind:

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

Getestet in folgenden Testfällen:

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)

Python 2 - 241 237 188 147 Bytes

Nimmt die Eingabe als in Anführungszeichen eingeschlossene Zeichenfolge in Kleinbuchstaben und mit Leerzeichen. Es muss einen besseren Weg geben.

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)

Ungolfed (260 ungerade Bytes)

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

Ziemlich genau wie die anderen Lösungen. Konvertieren Sie die Zeichenfolgen in einen Vektor aus ganzen Zahlen. Ändern Sie die Differenz der Vektoren um 26. Geben Sie einen eindeutigen Wert für die Liste ein, da die Länge 1 ist. Es wird erwartet, dass der Fall in den entsprechenden Zeichen in jeder Zeichenfolge gleich ist.

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

Es wartet auf die Eingabe der beiden Zeichenfolgen

> 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 / Octave, 53 52

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

Die Eingabe sollte immer vom selben Typ sein.

Leider ist Matlab nicht sehr gut mit Benutzereingaben. Als anonymes Handle können dies nur 35 Bytes sein:

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

Matlab behandelt die Zeichen einer Zeichenfolge als einen Vektor von Zahlen. Durch Subtraktion erhalten wir ihre Differenz und uniquewandeln diesen Vektor in einen Vektor um, der nur eindeutige Werte enthält. Wenn es nur eine Zahl gibt, sind die Wörter caeser-äquivalent und isscalar gibt 1 zurück, andernfalls wird 0 zurückgegeben.

Bash, 71 48

Verwenden des "Standard" -Unix-Programms caesar(6).

Neue Version (mit viel Hilfe von @DigitalTrauma):

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

• Die Eingaben müssen in derselben Zeile und durch Leerzeichen getrennt sein
• Die Groß- und Kleinschreibung muss zwischen den Eingaben übereinstimmen.
• Druckt 1für wahr oder nichts für falsch.

Wenn die Eingabe über Befehlszeilenargumente zulässig ist, kann sie auf 39 Byte verkürzt werden :

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

Alte Version für den Datensatz:

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

> <> (Fisch) , 50 Bytes

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

Erwartet, dass Briefe an derselben Position die gleiche Groß- / Kleinschreibung haben.

Erläuterung

• i:3b*(?vLiest das erste Wort in den Stapel, wobei 88+0.der Schleifensprung bereitgestellt wird
• ~ri-&Entfernt ~das Trennzeichen vom Stapel, kehrt den Stapel um r(der erste Buchstabe steht oben), liest den ersten Buchstaben des zweiten Wortes ein i, berechnet den Versatz zum ersten Buchstaben des ersten Wortes -und speichert ihn im Register &.
• l?!^i-&:&-2d*%0)?vLiest jeden nächsten Buchstaben des zweiten Wortes und subtrahiert ihn vom entsprechenden Buchstaben des ersten Wortes, der sich oben auf dem Stapel befindet. Subtrahiert den &:&-im Register gespeicherten Versatz und prüft, ob das Ergebnis 0 mod 26 ist 2d*%. Wenn nicht, wird 0 ausgegeben und beendet 0n;. c1.liefert den Schleifensprung.
• Wenn das Ende des zweiten Wortes erreicht ist, gibt das Programm 1 aus und bricht ab 1n;.

KDB (Q), 35 Bytes

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

Erläuterung

                         "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

Prüfung

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

erweitert:

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

Ich könnte 14 Bytes einsparen, wenn ich nicht mehr alles in Großbuchstaben umwandeln müsste, aber ich denke, es ist vollständiger, wenn ich es belasse.

Gelee , 5 Bytes

Oạ/ċ2

Probieren Sie es online!

Gibt eine positive Ganzzahl für Äquivalent aus, ansonsten 0

Wie es funktioniert

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