Deux chaînes sont "équivalentes à César" si la distance (comptage) entre les caractères correspondants est la même. Oui, j'ai inventé ce terme. Voici un exemple:

"Abc" et "Cde" sont équivalents car

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

La capitalisation ne fait aucune différence.

"Bonjour" et "Monde" ne sont pas équivalents à César car

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" et "Yzab" sont des équivalents César car

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

Vous devez écrire un programme complet qui prend deux chaînes de STDIN et imprime une valeur véridique si elles sont équivalentes à César et une valeur falsifiée si elles ne le sont pas.

Entrée valide

• Étant donné que la capitalisation n'a pas d'importance, il est acceptable si votre programme nécessite que les entrées soient toutes en minuscules, en majuscules ou quel que soit le mélange souhaité, tant que cela est spécifié dans votre réponse.

• L'entrée n'aura ni espaces ni ponctuation.

• Les entrées auront la même longueur.

Pyth, 9 octets

}wm=.rzGG

Les deux chaînes sont attendues en minuscules, séparées par des sauts de ligne.

Manifestation.

Comment ça marche:

.rest la fonction de traduction rotative de Pyth. Il mappe chaque élément du premier argument depuis sa première occurrence dans le deuxième argument jusqu'à l'entrée suivante dans le deuxième argument. Dans ce cas, le deuxième argument est Gl'alphabet minuscule, ce qui équivaut donc à un décalage César de 1.

Mettre un =devant la fonction le met en place. Ainsi, =.rzGaffecte le décalage César de zun à z. Notez qu'il zest initialisé à la première ligne d'entrée en Pyth.

Cette expression est utilisée dans une carte. m=.rzGGapplique cette transformation à z26 fois, une fois pour chaque élément de G, et enregistre les résultats dans une liste. Cela donne la liste de tous les changements de César possibles z.

Enfin, }wvérifie si la ligne d'entrée suivante se trouve dans cette liste.

CJam, 17 12 11 octets

1 octet enregistré par Dennis.

ll.m26f%)-!

Testez-le ici.

Attend que la première chaîne soit en minuscules et la seconde en majuscules. Imprime 1pour les chaînes équivalentes à César et 0autres.

Explication

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.

La raison pour laquelle nous avons besoin de la première chaîne en minuscules et de la seconde en majuscules est de garantir que la différence est toujours positive. Sinon, prendre le modulo pourrait retourner quelque chose de négatif et ne serait pas nécessairement unique, même pour les cordes équivalentes à César.

Python2, 68 67 70 69 octets

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

Python3, 67 66 octets

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

Il est un peu difficile de ne pas jouer au golf, alors expliquez simplement les pièces:

• zip(*raw_input().split())prend l'entrée, la divise en une liste de deux mots, en supposant que les mots sont séparés par des espaces. Après cela, chaque mot est passé en tant que paramètre de la zipfonction, à l'aide de l' *opérateur. La zipfonction créera une liste de paires de lettres, pour les lettres dans la même position.
• (ord(y)-ord(x))%26for x,y in ... Cela transforme simplement la liste de 2 lettres en une expression génératrice des distances entre ces lettres.
• {...} réduit cette expression à un ensemble, jetant essentiellement des doublons
• len(...)<2 vérifie s'il ne reste qu'un seul élément dans l'ensemble (ou 0 pour les chaînes vides), ce qui signifie essentiellement que toutes les lettres ont la même distance.
• print sort cette valeur

Merci à xnor de me le rappeler set(...)peut être remplacé par {...}et l'espace avant forn'est pas nécessaire. Grâce aussi à Josay pour l' <=1à l' <2optimisation.

APL (15)

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

Il a besoin que les lettres soient en majuscules et imprime soit 1ou 0, comme ceci:

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

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

Explication:

• ↑⍞⍞: lisez deux lignes sur le clavier et organisez les caractères dans une matrice N × 2.
• ⎕A⍳: pour chaque caractère, trouvez à quelle position il se trouve ⎕A(l'alphabet majuscule).
• -⌿: pour chaque colonne, soustrayez la deuxième valeur de la première valeur
• 26|: prenez le mod-26 de chacun de ces nombres.
• Si les chaînes sont équivalentes à César, tous les nombres de cette liste sont maintenant égaux, donc:
• ≢∪: trouver le nombre de valeurs uniques dans la liste
• 1=: comparer cela à 1.

J, 19 octets

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

Les lettres à la même position devraient avoir le même cas.

Après avoir converti les deux chaînes d'entrée en leur représentation de point de code avec &(3&u:)nous comparons 1à la longueur #du nœud ~.du modulo 26 26|de la différence -des deux tableaux. Le nœud sera 1si toutes les distances de César sont les mêmes.

Usage:

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

Essayez-le en ligne ici.

Julia, 91 87 83 octets

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

Non golfé + explication:

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

Cela tire parti du fait que les chaînes de Julia peuvent être traitées comme des tableaux de caractères et que des opérations arithmétiques peuvent être effectuées sur des valeurs de caractères. Les chaînes d'entrée peuvent avoir n'importe quelle combinaison de majuscules que vous souhaitez, tant que la capitalisation à chaque position correspond entre les chaînes.

C99, 92 octets avec bug   101 92 octets

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

Assez simple; suppose que les mots viennent respectivement comme premier et deuxième arguments. Compilé avec -std=c99.

Javascript ( ES7 Draft ), 87 octets

Nécessite que les entrées soient identiques.

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

{r(fm26f%}2*=

Il faut que le premier caractère de chaque mot soit en majuscule, les autres en minuscule.

Essayez-le ici . ( Firefox ici .)

Dommage que les variantes APL ne prennent pas en charge l'arithmétique des personnages ...

Explication

{
    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

Edit : une optimisation échouée s'était glissée dans le code du golf. Maintenant, il correspond à la version non golfée. (Le nombre d'octets était correct, cependant.)

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

Exécutez avec Perl version 5.10 ( perl -M5.10.0ou perl -E …) pour say(). Version légèrement élargie:

@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

Le code 1génère (véridique en Perl) si les chaînes sont équivalentes à César et la chaîne vide (fausse en Perl) si elles ne le sont pas. Si c'est une interprétation trop lâche, je dois ajouter 2 octets poursay$p+0 , qui imprime 1ou 0.

La casse des caractères doit correspondre entre les entrées.

Matlab, 49 48 octets

Ce fut très rapide. Malheureusement, obtenir une chaîne de stdin est assez cher.

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

Notez qu'il est, comme la plupart des réponses sinon toutes, sensible à la casse.

EDIT: rasé d'un octet en définissant une fonction anonyme!

Prolog, 56 octets

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

Toutes les combinaisons de cas ne sont pas prises en charge.

usage

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

Essayez-le en ligne ici

C, 97 octets

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

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

Un peu plus long que les autres, et essentiellement équivalent, mais il est dans un style de langue différent!

J'ai également cette version (56 octets):

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

Mais je ne sais pas si le fonctionnement de x $ 1 est une coïncidence ou par conception ...

Python 2, 80 octets

Prend 2 chaînes similaires de stdin séparées par un espace:

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

Testé sur les cas de test suivants:

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 octets

Prend l'entrée sous forme de chaîne minuscule entre guillemets, séparée par des espaces. Il doit y avoir une meilleure façon..

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)

Non golfé (260 octets impairs)

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

À peu près la même chose que les autres solutions. Convertissez les chaînes en un vecteur d'entiers. Modifiez la différence des vecteurs par 26. Faites un unique sur la liste car vérifiez que la longueur est 1. Il s'attend à ce que la casse soit la même en caractères correspondants dans chaque chaîne.

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

Il attend que les deux chaînes soient entrées

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

Les entrées doivent toutes être du même cas.

Malheureusement, Matlab n'est pas très bon avec les commentaires des utilisateurs. En tant que descripteur anonyme, cela ne peut représenter que 35 octets:

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

Matlab traite les caractères d'une chaîne comme un vecteur de nombres. Faire la soustraction nous fait leur différence, etunique convertit ce vecteur en un vecteur contenant uniquement des valeurs uniques. S'il n'y a qu'un seul nombre, les mots sont équivalents céser et isscalar renvoie 1, sinon il retournera 0.

bash, 71 48

Utilisation du programme Unix «standard» caesar(6).

Nouvelle version (avec beaucoup d'aide de @DigitalTrauma):

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

• Les entrées doivent être sur la même ligne, séparées par des espaces
• La casse des caractères doit correspondre entre les entrées.
• Imprime 1pour vrai ou rien pour faux.

Si l'entrée via des arguments de ligne de commande est autorisée, elle peut être raccourcie à 39 octets :

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

Ancienne version pour le dossier:

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

> <> (Poisson) , 50 octets

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

S'attend à ce que les lettres au même endroit aient la même casse.

Explication

• i:3b*(?vlit le premier mot dans la pile en 88+0.fournissant le saut en boucle
• ~ri-&supprime ~l'espace de séparation de la pile, inverse la pile r(la première lettre sera en haut), lit la première lettre du deuxième mot i, calcule le décalage par rapport à la première lettre du premier mot -et le stocke dans le registre &.
• l?!^i-&:&-2d*%0)?vlit chaque lettre suivante du deuxième mot en la soustrayant de la lettre correspondante du premier mot qui est en haut de la pile soustrait l'offset &:&-stocké dans le registre et vérifie si le résultat est 0 mod 26 2d*%. Sinon, imprime 0 et se termine 0n;. c1.fournit le saut en boucle.
• S'il est atteint à la fin du deuxième mot, le programme imprime 1 et se termine 1n;.

KDB (Q), 35 octets

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

Explication

                         "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

Tester

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

étendu:

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

Je pourrais économiser 14 octets si je me débarrassais de tout convertir en majuscules, mais j'ai l'impression qu'il est plus complet de le laisser.

Gelée , 5 octets

Oạ/ċ2

Essayez-le en ligne!

Génère un entier positif pour l'équivalent, 0 sinon

Comment ça marche

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