Le César de César est un chiffre de substitution très simple où chaque lettre est décalée d'un décalage fixe (boucle autour de Z vers A). De même, nous pouvons également utiliser un chiffre César pour l'ensemble des caractères ASCII imprimables. Ce sont les 95 caractères des points de code 0x20 à 0x7E. Pour un décalage donné d, nous mappons le point de code Csur

(C - 32 + d) % 95 + 32

qui décale tous les caractères par un det fait une boucle dans l' ~espace. Les caractères en dehors de cette plage (les caractères de contrôle comme les sauts de ligne, les tabulations et les caractères en dehors de la plage ASCII) ne sont pas affectés.

Vous devez écrire deux programmes ou fonctions (potentiellement dans des langues différentes), qui prennent un décalage det une chaîne. Le premier programme doit retourner ou imprimer le chiffre César de l'entrée. Le deuxième programme devrait retourner ou imprimer le chiffre César inverse (c'est-à-dire en utilisant l'offset -d). Vous pouvez saisir des données via STDIN, un argument de ligne de commande ou un argument de fonction.

Pour rendre les choses plus intéressantes, le deuxième programme doit être un chiffre César du premier programme. Autrement dit, si vous passez le code source du premier programme à lui-même, pour certains décalages non nuls d, la sortie doit être le deuxième programme.

Les deux programmes, ainsi que les chaînes d'entrée, ne doivent contenir que des caractères ASCII imprimables, des nouvelles lignes et des tabulations. Aucun programme ne peut contenir de commentaires ou lire son propre code source, nom de fichier ou ID de processus directement ou indirectement.

Il s'agit du code golf, donc la réponse la plus courte (en octets) l'emporte. Étant donné que les deux programmes doivent avoir la même taille, vous ne devez le compter qu'une seule fois.

Cjam, 40 38 37 octets

Cypher avant:

 q~'~),32>_@m<er "o|%|'*10<]>k<cpZ"_-

Cypher inverse:

"s!)!+.54@aBo>gt"$q~'~),32>_@m>er\$a/

et le deuxième programme est le chiffre du premier avec une différence de 2

Comment ça marche

J'ai trouvé cette réponse par pure chance en testant les choses.

Tout d'abord, les parties Cypher:

q~'~),32>_@m<er
q~                 "Take the input and evaluate it";
  `~)              "Get the next character after the printable ASCII range";
     ,32>          "Get all printable ASCII characters":
         _@        "Copy the printable ASCII string and bring the cypher difference"
                   "on top of stack";
           m<      "Forward rotate the copy of printable ASCII string by difference";
                   "In case of inverse Cypher, this is m> to reverse rotate the string";
             er    "Transliterate to complete the forward/inverse Cypher";

Vient maintenant l'explication de la partie délicate.

Les transformations clés sont

<space> -> "     // Empty space to string conversion
Z -> \           // Character Z in an useless string to swap operation
_ -> a           // Copy operation to wrapping in an array
- -> /           // Set subtraction to string splitting

Le premier programme est donc

 q~'~),32>_@m<er "o|%|'*10<]>k<cpZ"_-
 q~'~),32>_@m<er                          "no-op space, Forward cypher, no-op space";
                 "o|%|'*10<]>k<cpZ"       "Useless String (Actually not)";
                                   _      "Copy it and ..."
                                    -     "remove all alphabets of copy from original";

Et le deuxième programme est

"s!)!+.54@aBo>gt"$q~'~),32>_@m>er\$a/
"s!)!+.54@aBo>gt"                       "Cypher of first part of first program"
                                        "with difference of 2";
                 $q~'~),32>_@m>er\$a/   "Cypher of the useless string of first program";
                                        "with difference 2";
                 $                      "Sort the first program's main part's cypher";
                  q~'~),32>_@m>er       "Program to reverse cypher";
                                 \$     "Swap the cypher to the top of stack and sort it";
                                   a    "Wrap it in array";
                                    /   "Split the output string on an array, which";
                                        "always returns the output in an array as there";
                                        "are no occurrences of an array in a string";

L'entrée est comme "<escaped string to be cyphered>" <difference>

Par exemple:

"abcd" 4

et la sortie du premier programme est

efgh

et du deuxième programme est

]^_`

Essayez-le en ligne ici

Python 2, 147

Clairement, je n'ai pas trop réfléchi à celui-ci, car ce serait inutile en Python. Il y a simplement deux programmes séparés, celui inutilisé étant enfermé dans une chaîne.

Le décalage entre les deux programmes est de 39.

Vers l'avant

Définit la fonction Z acceptant une chaîne Unicode et un décalage.

Z=lambda s,d:s.translate({i+32:(i+d)%95+32for i in range(95)})or u''and Z
"uE:F;=:XLd=rLfMK:GLE:M>`TBckjr`Be=a]qmckj?HKXBXBGXK:G@>`qmaVaHKXN__:G=X"

Inverse

Définit la fonction que j'accepte une chaîne Unicode et un décalage.

"d4)5*,)G;S,a;U<:)6;4)<-OC1RZYaO1R,PL`\RZY.7:G1G16G:)6/-O`\PEP7:G=NN)6,G"
I=lambda s,d:s.translate({i+32:(i-d)%95+32for i in range(95)})or u''and I

Python 3 - 248 octets

Mon objectif était de le faire en tant que monoplace Python. Succès de l'objectif, mais maintenant je ne peux pas être dérangé par le golf.

Crypter:

r=q="".__doc__[2];eval("p"+q+"int(''.join([c,ch"+q+"((o"+q+"d(c)-32+d)%95+32)][31<o"+q+"d(c)<127]fo"+q+" d in[int(input())]fo"+q+" c in input()))")or'\^UZ`smmyV[UZsGOwOT^ss[^PsOtx~}xPtp%!v~}tIG~|([^PsOt(|}$IR[^kPkUZGUZ`sUZ\a`sttIR[^kOkUZkUZ\a`sttt'

Déchiffrer:

'Q&Q66Bssx$wssoFqOy+u!<6%6?&?6}#)<;;B~$}#<ow@w|6?&?6<<$6?&?6x<w=AGF?x=9MI?GF=qoGEP$6?&?6x<w=PEFKqz$6?&?64x4}#o}#)<}#%*)<==qz$6?&?64w4}#4}#%*)<===6=$';print("".join([c,chr((ord(c)-32-d)%95+32)][31<ord(c)<127]for d in[int(input())]for c in input()));

Modifier: corrigé pour ne pas affecter les caractères en dehors de la plage ASCII imprimable

Le décalage de crypter à décrypter est de 20. À utiliser en entrant d'abord le décalage, puis la chaîne,

5
hello

Explication

Les transformations suivantes sont la clé:

r -> '
' -> ;

Le premier autorise l'utilisation de or, tandis que le second ignore une chaîne par des points-virgules.

Notez que "".__doc__[2]renvoie la chaîne r(tirée de str). Cela est nécessaire pour empêcher la chaîne entre guillemets simples dans le programme de déchiffrement d'avoir des guillemets parasites au milieu.

Rubis, 131 125 octets

Voici ma propre soumission (que j'avais écrite plus tôt comme preuve de concept, mais j'ai réussi à violer mes propres règles d'une manière ou d'une autre). Je ne réutilise aucun code entre les deux soumissions (je veux que vous battiez cela, après tout), mais à la place, il se compose de deux lignes, dont l'une est transformée en chaîne avec du charabia.

Cypher avant:

Y=->d,s{s.chars{|c|x=c.ord;$><<(x<32?x:(x-32+d)%95+32).chr}};Y
"tdu<cKSKe;@9JKST;TPt;eGJ<r[uss_PsjivPq_Pdjid<`\plbji`e;@JUUr"

Chiffre inverse:

"eUf-T<D<V,1*;<DE,EAe,V8;-cLfddPAd[ZgAbPAU[ZS-QMa]S[ZQV,1;FFc"
J=->d,s{s.chars{|c|x=c.ord;$><<(x<32?x:(x-32-d)%95+32).chr}};J

Les deux extraits définissent une fonction (appelée Ydans la première et Jdans la seconde), qui prend un entier et une chaîne et imprime la chaîne transformée dans STDOUT. Le décalage entre les deux morceaux de code est 40.

oOo CODE , 750 744 octets, tout le code utilisé dans les deux programmes

Trop long mais c'est probablement le bon outil pour faire ça ...

Crypter:

CcCcccccccccCcYcccCCCccCcCcCccccccCcCcccccCcCcccCcCccCccCcCCccccCcCccccCCcCccccCCccCccCcCCcccCCCcCccccCcCCcCCcCCcCcCcCccccCCccCccCccCccCccCccCccCccccccCCCcCccCccCCcCcCcccCCcCcccCcCCcCCcCcCCccCCcCCcCCcCCcCCcCCcCCcCCcCCcCCcCcccccccCccccCccccCCccccCCcCccCCcccCccccccccccCcCccCccCccCccCcCCccCCcccCcCcCccCCcccCCCcCcccccccccccccCCccCccCcCcCcccCCccccccccccCcCccccccCcCccccCCcCccCccCCcCccccccccccCCccCcCcCcccccCcCccCcCCCcCccCccCCcCccCccCccCcCcccccCcCcccCCCcCcCccccCcCccCCcCCcCCcCcCCcccCcCCcCCcCCcCCcCCcCCcCCcCCcCCcCcCcccCccCCcccccCcCcccCcccccCcccCcccCccCccCCcCcccccccccccccCCCcccCcCcCcccCcccCCCcCccCccCccCcCCccCccCcCCCcCccccCcCccccccccCcCccCccCcCCccccccCccccccccCcccCCccCccCccCCcCCcCCcCCcCcCcCcccccCcCCcCCcCCcCCcCCcCCcCCcCccCcCCcccCCccCcCcccCCcccCCCcCC

Déchiffrer:

SsSsssssssssSsisssSSSssSsSsSssssssSsSsssssSsSsssSsSssSssSsSSssssSsSssssSSsSssssSSssSssSsSSsssSSSsSssssSsSSsSSsSSsSsSsSssssSSssSssSssSssSssSssSssSssssssSSSsSssSssSSsSsSsssSSsSsssSsSSsSSsSsSSssSSsSSsSSsSSsSSsSSsSSsSSsSSsSSsSsssssssSssssSssssSSssssSSsSssSSsssSssssssssssSsSssSssSssSssSsSSssSSsssSsSsSssSSsssSSSsSsssssssssssssSSssSssSsSsSsssSSssssssssssSsSssssssSsSssssSSsSssSssSSsSssssssssssSSssSsSsSsssssSsSssSsSSSsSssSssSSsSssSssSssSsSsssssSsSsssSSSsSsSssssSsSssSSsSSsSSsSsSSsssSsSSsSSsSSsSSsSSsSSsSSsSSsSSsSsSsssSssSSsssssSsSsssSsssssSsssSsssSssSssSSsSsssssssssssssSSSsssSsSsSsssSsssSSSsSssSssSssSsSSssSssSsSSSsSssssSsSssssssssSsSssSssSsSSssssssSssssssssSsssSSssSssSssSSsSSsSSsSSsSsSsSsssssSsSSsSSsSSsSSsSSsSSsSSsSssSsSSsssSSssSsSsssSSsssSSSsSS

Traductions de Brainfuck:

+>>>+>,<[->[->+>+<<]>[-<+>]<<]>,[>++++[-<-------->]+<<+[<+>+++]<++++++++++>>[>-<-<+<-[>>>+<<<<]<-[+<-]+>>>>]<<[-]>>>[->[-<+<<+>>>]<[->+<]+<<+<<<[>[-]+[>+<+++]>++++++++++[<<->+>->-[<<<+>>>>]-[+>-]+<<<]<<]+>[->>+<<]>>->>-]<<<++++[->++++++++<]>.[-]>,]
+>>>->,<[->[->+>+<<]>[-<+>]<<]>,[>++++[-<-------->]+<<+[<+>+++]<++++++++++>>[>-<-<+<-[>>>+<<<<]<-[+<-]+>>>>]<<[-]>>>[->[-<+<<+>>>]<[->+<]+<<+<<<[>[-]+[>+<+++]>++++++++++[<<->+>->-[<<<+>>>>]-[+>-]+<<<]<<]+>[->>+<<]>>->>-]<<<++++[->++++++++<]>.[-]>,]

oOo CODE est une variante de Brainfuck où seul le cas des lettres compte.

Il prend le premier octet et utilise son code de caractère comme d(donc une nouvelle ligne signifie d = 10). Le reste de l'entrée est la chaîne. EOF est 0.

GolfScript, 95 64 octets, tout le code utilisé dans les deux programmes

Crypter:

0 0z{ 1)'[}??)9t:z21,--/; [84;%zt*84*84$|)21*|$Z!!\~'---|}`{)}%~

Déchiffrer:

1!1{|!2*(\~@@*:u;{32-..0<!\95<&{u+95+95%}*32+}%[""] (...}~a|*~& 

Format d'entrée:

1 "0 0z{ 1)'[}??)9t:z21,--/; [84;%zt*84*84$|)21*|$Z!!\~'---|}`{)}%~"

Explication

Déchiffrer:

1!1                            # Push 0 1.
{                              # Define a block and evaluate it.
    |                          # Or.
    !2*(                       # Get 1 for encryption, or -1 for decryption.
    \~                         # Evaluate the input string.
    @@*:u;                     # u = d for encryption, or -d for decryption.
    {                          # For each character:
        32-                    # Subtract 32.
        ..0<!\95<&             # Test if it is in the printable range.
        {u+95+95%}*            # If so, add u (mod 95).
        32+                    # Add 32 back.
    }%
    [""] (...                  # Push an empty array and 4 empty strings.
}~
a                              # No-op.
|*~                            # Evaluate ""*(""|"") which does nothing.
&                              # Calculate []&"" which is empty.

Crypter:

0 0                            # Push 0 0.
z                              # No-op.
{                              # Define a block and get its string representation.
    ...                        # See decryption code.
    |                          # This will be decoded into a }. The string will be truncated here when evaluated.
}`                             # Only the closing } will be truncated, but it is still used as the end of the block.
{)}%                           # Increment each character. Note that the braces before and after the block will also be incremented.
~                              # Evaluate the string.

Javascript (ES7 Draft) - 167 165 octets

Emprunt de l'utilisation des chaînes par @feersum et de l'utilisation des points-virgules par @MartinButtner;)

Crypter:

J=(s,d)=>s.replace(/[ -~]/g,x=>String.fromCharCode((x.charCodeAt()-32+d)%95+32));J
"eP<T-Qef<V;.95*,.PW$HUG&W0TAef{=;270V/;86k1*;k8-.PPAV,1*;k8-.i=PQS^[U-QMa]S[ZQQc"

Déchiffrer:

"t_Kc<`tuKeJ=HD9;=_f3WdV5f?cPtu+LJAF?e>JGEz@9JzG<=__Pe;@9JzG<=xL_`djib<`\plbji``r"
Y=(s,d)=>s.replace(/[ -~]/g,x=>String.fromCharCode((x.charCodeAt()+63-d)%95+32));Y

Décalage à utiliser: 55

> <> (Poisson) , 467 octets

Crypter:

ffii{{~~__:0a('0'*!.0a('0'*22(!'(~$~_:}-}$-a*}+{{if~~:i:0({}?;__:{}84{}*__({}?\__:{} _{}70{}g_{})_{}?\4__{}8*-_{}+{}80{}g_%4_{}8*{}+\\sl||||||||||||||||||||||||||||9||||||||||||||9||||||||||||||||||||||||||||||||||||||||||||||||||||9
                                                                              >                      >                              >!;7f7-_{}!%_{}!<872-d_{}!&_{}!<[755(7(%~~_{}!<[55(7(_{}!*!*23a(_{}!'_{}!"55(7((~~_{}~~~o__'4'0.{{{o,

Déchiffrer:

iill~~""bb=3d+*3*-$13d+*3*-55+$*+"'"b=!0!'0d-!.~~li""=l=3+~!B>bb=~!;7~!-bb+~!B_bb=~!#b~!:3~!jb~!,b~!B_7bb~!;-0b~!.~!;3~!jb(7b~!;-~!.__vo                            <              <                                                    <
##############################################################################A######################A##############################A$>:i:0b~!$(b~!$?;:50gb~!$)b~!$?^:88+:+(""b~!$?^88+:+b~!$-$-56d+b~!$*b~!$%88+:++""b~!"""rbb*7*31~~~r/

Les deux programmes sont décalés de 3 et prennent la forme:

<2-digit offset> <text>

Le décalage doit être de 2 chiffres, donc un décalage de 5 doit être entré comme 05.

Il s'agit d'une longue soumission, mais presque tous les caractères non remplisseurs sont utilisés par les deux programmes . Il y a beaucoup d'espaces qui peuvent certainement être joués au golf, mais je pensais que le programme serait plus intéressant de cette façon.

Cette image met en évidence les caractères utilisés par les deux programmes.

Explication

La construction principale qui rend cela possible est _{} -> b~!, qui permet de sauter arbitrairement des caractères dans le programme de déchiffrement. Comment?

Encrypt:
  _ : Mirror, but is a no-op if the program flow is horizontal
  { : Shift stack left
  } : Shift stack right

Decrypt:
  b : Push 11 to stack
  ~ : Pop top of stack
  ! : Skip the next instruction

Dans l'ensemble, le programme de cryptage ne fait rien, mais le programme de décryptage ignore l'instruction suivante. Cela peut ensuite être étendu à _{}! -> b~!$, ce qui permet à la place de sauter arbitrairement des caractères dans le programme de chiffrement .

En dehors de cela, la plupart du reste du programme consiste à pousser les numéros, à effectuer des opérations sur ces numéros, puis à trouver des moyens de les faire apparaître. Par exemple, une construction utile est ~~ -> "", qui affiche deux valeurs pour le programme de chiffrement, mais ne pousse rien dans le programme de déchiffrement.

> <>, 149 octets

Voici la version la moins intéressante, qui utilise le fait que les instructions non transmises sont en fait des commentaires en langage 2D.

Crypter:

i68*:@-a*i@@-+i~v
4:v?)g31:;?(0:i:/8
(?v48*-+03g%48*+\*
_~\of0.   .1+1fo/
j*+:zq<6B99A6=qz6g
53Ji?C58/8;?r0?C5:
C?EiJ4r?<EFJ3;EtEg
:tAC5EK8l5tKK86t*i

Déchiffrer:

^+-~/5"V~^55" ^sk
)/k4}\(&/04|%/^/$-
|4k)-~" %(\y)-~ Q~
TsQd[%#ttt#& &[d$
_~ /of1+7..6+2fo+\
*(?^48*-$-04g%48*/
84:^?)g41:;?(0:i:\
/i68*:@-a*i@@-+i~^

Les deux programmes sont décalés de 84 et prennent les entrées de la même manière que ci-dessus. La première instruction décide quelle moitié du programme exécuter, avec i(entrée) maintenant le flux du programme vers la droite dans le programme de cryptage et ^redirigeant le flux du programme vers le haut (en boucle et en revenant par le bas) dans le programme de décryptage.

Explication

Pour la moitié pertinente du programme de cryptage (le programme de décryptage est similaire):

i                       read first input digit as char
68*:@-a*                subtract 48 (ASCII "0") and multiply by 10, keeping another 48 on the stack
i                       read second input digit as char
@@-+                    subtract 48 and add to 10*(first digit), giving the offset
i~                      read in space and discard it

--- LOOP ---
:                       copy the offset
i:                      read input char
:0)?;                   check if less than 0 (i.e. EOF) and terminate if so
:13g)?v                 check if greater than ~ in cell (1,3) and drop down if so
48*(?v                  check if less than 32 and drop down if so
48*-+03g%48*+           calculate Caesar shift of the char, fetching 95 from (0,3)

of1+1.                  repeat loop
of0.                    repeat loop

Outil de codage

Ce n'est pas lié au reste du post ci-dessus, mais je pensais que je posterais ceci parce que je dois l'utiliser: P

for(var i=0;i<95;++i){var option=document.createElement("option");option.text=i;document.getElementById("offset").add(option)};function update(m){if(m==1)var code=document.getElementById("in").value;else var code=document.getElementById("out").value;var offset=parseInt(document.getElementById("offset").value);var output="";for(var i=0;i<code.length;i++){var n=code[i].charCodeAt(0);if(n<32||n>127)output+=code[i];else{var c=(n-32+offset*m)%95;output+=String.fromCharCode(c<0?c+95+32:c+32)}}if(m==1)document.getElementById("out").value=output;else document.getElementById("in").value=output};

<html><body><textarea id="in" onkeyup="update(1)" rows=5 style="width:100%"></textarea><textarea id="out" rows=5 style="width:100%" onkeyup="update(-1)"></textarea><select id="offset" onchange="update(1)"></select></body></html>

Perl - 131

Il prend l'entrée des arguments de ligne de commande.

We;{for(split//,$ARGV[1]){print chr(((ord$_)-32+$ARGV[0])%95+32)}};q!LUXmYVROZttqi'8-<AvCnaVXOTZeINXmmmUXJiEnrxwri'8-<AuCnj~zpxwnc!

Le décaler de 26 donne l'autre:

q U6!*-B.+'$/IIF>[lapuKwC6+-$)/:}#-BBB*-~>yCGMLE>[lapuJwC?SOEMLC88U,;for(split//,$ARGV[1]){print chr(((ord$_)-32-$ARGV[0])%95+32)};