Dwa ciągi znaków są „odpowiednikiem Cezara”, jeśli odległość (zliczanie w górę) między odpowiednimi znakami jest taka sama. Tak, wymyśliłem ten termin. Oto przykład:

„Abc” i „Cde” są równoważne, ponieważ

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

Wielkie litery nie mają znaczenia.

„Cześć” i „Świat” nie są odpowiednikami Cezara, ponieważ

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” i „Yzab” są odpowiednikami Cezara, ponieważ

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

Musisz napisać pełny program, który pobiera dwa ciągi ze STDIN i wypisuje prawdziwą wartość, jeśli są one równoważne Cezarowi, i wartość fałsz, jeśli tak nie jest.

Prawidłowe dane wejściowe

• Ponieważ wielkie litery nie mają znaczenia, jest dopuszczalne, jeśli Twój program wymaga, aby dane wejściowe były pisane małymi literami, wszystkie dużymi literami lub dowolną mieszanką, o ile jest to określone w odpowiedzi.

• Na wejściu nie będzie spacji ani interpunkcji.

• Wejścia będą tej samej długości.

Pyth, 9 bajtów

}wm=.rzGG

Te dwa ciągi znaków są zapisane małymi literami, oddzielone znakiem nowej linii.

Demonstracja.

Jak to działa:

.rjest funkcją tłumaczenia obrotowego Pytha. Odwzorowuje każdy element w pierwszym argumencie od pierwszego wystąpienia w drugim argumencie do następnego wpisu w drugim argumencie. W tym przypadku drugim argumentem jest Gmały alfabet, więc jest to równoważne przesunięciu Cezara o 1.

Umieszczenie =przed funkcją powoduje, że jest ona na miejscu. W ten sposób =.rzGprzypisuje przesunięcie Cezara o zjeden do z. Zauważ, że zjest inicjowany do pierwszego wiersza wprowadzania w Pyth.

To wyrażenie jest używane w mapie. m=.rzGGstosuje tę transformację do z26 razy, raz dla każdego elementu G, i zapisuje wyniki na liście. Daje to listę wszystkich możliwych przesunięć Cezara z.

Na koniec }wsprawdza, czy następny wiersz danych wejściowych znajduje się na tej liście.

CJam, 17 12 11 bajtów

1 bajt zapisany przez Dennisa.

ll.m26f%)-!

Sprawdź to tutaj.

Oczekuje, że pierwszy ciąg będzie pisany małymi literami, a drugi - dużymi literami. Odbitki 1dla łańcuchów równoważnych Cezarowi i 0innych.

Wyjaśnienie

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.

Powodem, dla którego potrzebujemy pierwszego łańcucha pisanego małymi literami, a drugiego pisanego dużymi literami jest zapewnienie, że różnica jest zawsze dodatnia. W przeciwnym razie przyjęcie modulo może zwrócić coś negatywnego i niekoniecznie będzie unikalne, nawet dla łańcuchów równoważnych Cezarowi.

Python2, 68 67 70 69 Bajtów

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

Python3, 67 66 bajtów

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

Ungolf jest trochę trudny, więc po prostu wyjaśnij:

• zip(*raw_input().split())pobiera dane wejściowe, dzieli je na listę dwóch słów, zakładając, że słowa są oddzielone spacją. Następnie każde słowo jest przekazywane jako parametr zipfunkcji za pomocą *operatora. zipFunkcja stworzy listę par liter, listów w tej samej pozycji.
• (ord(y)-ord(x))%26for x,y in ... To po prostu przekształca listę 2 liter w generator wyrażenia odległości między tymi literami.
• {...} redukuje to wyrażenie do zbioru, zasadniczo wyrzucając duplikaty
• len(...)<2 sprawdza, czy w zestawie pozostała tylko jedna pozycja (lub 0 dla pustych ciągów), co w zasadzie oznacza, że ​​wszystkie litery miały tę samą odległość.
• print wyprowadza tę wartość

Dzięki xnor za przypomnienie mi set(...)można go zastąpić, {...}a wcześniejsza przestrzeń fornie jest wymagana. Również dzięki Josay dla osób <=1do <2optymalizacji.

APL (15)

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

Potrzebuje wielkich liter i drukuje albo, 1albo 0tak:

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

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

Wyjaśnienie:

• ↑⍞⍞: odczytaj dwie linie z klawiatury i ustaw znaki w macierzy N × 2.
• ⎕A⍳: dla każdego znaku znajdź miejsce, w którym występuje ⎕A(wielkie litery).
• -⌿: dla każdej kolumny odejmij drugą wartość od pierwszej wartości
• 26|: weź mod-26 każdej z tych liczb.
• Jeśli ciągi znaków są równoważne Cezarowi, wszystkie liczby na tej liście są teraz równe, więc:
• ≢∪: znajdź liczbę unikalnych wartości na liście
• 1=: porównaj to z 1.

J, 19 bajtów

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

Listy w tej samej pozycji powinny mieć tę samą literę.

Po przekonwertowaniu obu ciągów wejściowych na ich reprezentację punktu kodowego &(3&u:)porównujemy 1z długością #wierzchołka ~.modułu 26 26|różnicy -dwóch tablic. Nub będzie, 1jeśli wszystkie odległości Cezara są takie same.

Stosowanie:

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

Wypróbuj online tutaj.

Julia, 91 87 83 bajtów

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

Niegolfowane + wyjaśnienie:

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

Wykorzystuje to fakt, że ciągi w Julii mogą być traktowane jako tablice znaków, a operacje arytmetyczne można wykonywać na wartościach znaków. Ciągi wejściowe mogą mieć dowolną kombinację wielkich liter, o ile wielkość liter w każdej pozycji jest zgodna między ciągami.

C99, 92 bajty z błędem   101 92 bajty

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

Całkiem proste; zakłada, że ​​słowa są odpowiednio pierwszym i drugim argumentem. Kompilowany z -std=c99.

JavaScript ( wersja robocza ES7 ), 87 bajtów

Wymaga, aby dane wejściowe były takie same.

(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 bajtów

{r(fm26f%}2*=

Wymaga, aby pierwszy znak w każdym słowie był pisany wielkimi literami, a inne małymi.

Wypróbuj tutaj . ( Firefox tutaj .)

Szkoda, że ​​warianty APL nie obsługują arytmetyki postaci ...

Wyjaśnienie

{
    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

Edycja : Nieudana optymalizacja przeszła do kodu golfowego. Teraz pasuje do wersji bez golfa. (Liczba bajtów była jednak poprawna).

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

Uruchom z Perlem w wersji 5.10 ( perl -M5.10.0lub perl -E …) dla say(). Lekko rozszerzona wersja:

@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

Kod wyprowadza 1(prawda w Perlu), jeśli ciągi są równoważne Cezarowi, a pusty ciąg (fałsz w Perlu), jeśli nie są. Jeśli jest to zbyt luźna interpretacja, muszę dodać 2 bajty, dla say$p+0których drukuje 1lub 0.

Wielkość liter musi się zgadzać między wejściami.

Matlab, 49 48 bajtów

To było naprawdę szybkie. Niestety zdobycie sznurka ze standardowego wejścia jest dość drogie.

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

Zauważ, że podobnie jak większość, jeśli nie wszystkie odpowiedzi, rozróżniana jest wielkość liter.

EDYCJA: odcięto jeden bajt, definiując anonimową funkcję!

Prolog, 56 bajtów

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

Nie wszystkie kombinacje przypadków są obsługiwane.

stosowanie

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

Wypróbuj online tutaj

C, 97 bajtów

#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 bajtów

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

Trochę dłużej niż inne i zasadniczo równoważne, ale jest w innym stylu językowym!

Mam również tę wersję (56 bajtów):

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

Ale nie wiem, czy działanie x 1 USD jest zbiegiem okoliczności czy z założenia ...

Python 2, 80 bajtów

Pobiera 2 podobnie napisane ciągi ze standardowego wejścia oddzielone spacją:

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

Testowany na następujących przypadkach testowych:

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 bajtów

Pobiera dane wejściowe jako małe litery ujęte w cudzysłowy, oddzielone spacjami. Musi być lepszy sposób ...

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)

Niegolfowane (260 bajtów nieparzystych)

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

Dosyć podobnie jak inne rozwiązania. Konwertuj ciągi na wektor liczb całkowitych. Zmodyfikuj różnicę wektorów o 26. Wykonaj unikat na liście, sprawdzając, czy długość wynosi 1. Oczekuje, że wielkość liter będzie taka sama w odpowiednich znakach w każdym łańcuchu.

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

Czeka na wprowadzenie dwóch ciągów

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

Dane wejściowe powinny być w tym samym przypadku.

Niestety Matlab nie radzi sobie dobrze z wprowadzaniem danych przez użytkownika. Jako anonimowy uchwyt może to być tylko 35 bajtów:

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

Matlab traktuje znaki ciągu jako wektor liczb. Odejmowanie daje nam różnicę i uniqueprzekształca ten wektor w wektor zawierający tylko unikalne wartości. Jeśli jest tylko jedna liczba, słowa są równoważne caeser i isscalar zwraca 1, w przeciwnym razie zwróci 0.

bash, 71 48

Korzystanie ze „standardowego” programu uniksowego caesar(6).

Nowa wersja (z dużą pomocą @DigitalTrauma):

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

• Wejścia muszą znajdować się w tym samym wierszu, oddzielone spacjami
• Wielkość liter musi się zgadzać między wejściami.
• Drukuje 1za prawda lub nic za fałsz.

Jeśli dozwolone jest wprowadzanie za pomocą argumentów wiersza poleceń, można je skrócić do 39 bajtów :

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

Stara wersja rekordu:

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

> <> (Ryby) , 50 bajtów

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

Oczekuje, że litery w tej samej pozycji będą miały tę samą wielkość liter.

Wyjaśnienie

• i:3b*(?v wczytuje pierwsze słowo do stosu za pomocą 88+0. zapewniając skok w pętli
• ~ri-&usuwa ~spację oddzielającą od stosu, odwraca stos r(pierwsza litera będzie na górze), czyta pierwszą literę drugiego słowa i, oblicza przesunięcie od pierwszej litery pierwszego słowa- i zapisuje go w rejestrze &.
• l?!^i-&:&-2d*%0)?vodczytuje każdą kolejną literę drugiego słowa odejmując go od odpowiedniej litery pierwszego słowa, która znajduje się na górze stosu, odejmuje przesunięcie &:&-zapisane w rejestrze i sprawdza, czy wynikiem jest 0 mod 26 2d*%. Jeśli nie, drukuje 0 i kończy 0n;. c1.zapewnia skok pętli.
• Po osiągnięciu końca drugiego słowa program wypisuje 1 i kończy 1n;.

KDB (Q), 35 bajtów

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

Wyjaśnienie

                         "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

Test

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

rozszerzony:

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

Mógłbym zaoszczędzić 14 bajtów, gdybym pozbył się konwertowania wszystkiego na wielkie litery, ale wydaje mi się, że lepiej jest zostawić to.

Galaretka , 5 bajtów

Oạ/ċ2

Wypróbuj online!

Zwraca dodatnią liczbę całkowitą dla ekwiwalentu, w przeciwnym razie 0

Jak to działa

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