César changeant

22

Un changement de César est probablement quelque chose que nous connaissons tous.

(Vous pourriez même le faire comme devoir. Si c'est le cas, veuillez ne pas copier ces réponses, votre professeur ne veut certainement pas quelque chose comme les réponses ici.)

Au cas où vous ne le seriez pas, un changement de César est une forme de chiffrement très simple. Il faut une chaîne à chiffrer et un entier. Ensuite, pour chaque caractère alphabétique de la chaîne, effectuez la transformation suivante:

  1. Déterminez la position du personnage dans l'alphabet (basé sur 0).
  2. Ajoutez à ce nombre l'entier reçu au début.
  3. Alors que le nombre est supérieur à 25, soustrayez-en 26.
  4. Déterminez la position de l'alphabet dans lequel il se trouve.

Laissez le reste des personnages inchangé.

Les majuscules doivent être respectées car qu'est-ce que l'anglais sans majuscules?

Exemples:

abcdefghijklmnopqrstuvwxyz 1 -> bcdefghijklmnopqrstuvwxyza
Spam spam spam sausage and spam! 13 -> Fcnz fcnz fcnz fnhfntr naq fcnz!
abcdefghijklmnopqrstuvwxyz 52 -> abcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz -1 -> zabcdefghijklmnopqrstuvwxy
ABCxyz 3 -> DEFabc

Hypothèses

  • Vous pouvez recevoir n'importe quel caractère ASCII imprimable
  • Le nombre d'entrée peut être négatif et sera toujours supérieur à -128 et inférieur à 128 ( -128<x<128)
  • Vous devez être en mesure de coder les majuscules et les lettres non majuscules de manière réversible.
  • Vous devez créer un programme complet, pas seulement une fonction ou un extrait
  • Vous obtiendrez votre contribution de STDIN ou de son remplaçant le plus proche
  • Vous pouvez choisir le format de votre contribution, veuillez l'indiquer dans votre réponse

  • Les caractères qui doivent être réorientées sont codepoints ASCII 0x41 - 0x5Aet 0x61-0x7A- majuscules et minuscules

    • Les lettres majuscules doivent rester en haut
    • Les lettres minuscules doivent rester plus basses
    • Les caractères ne se trouvant pas dans cette plage doivent être laissés tels quels

  • Remarque pour ce défi, vous n'avez qu'à chiffrer les chaînes, vous n'avez pas à être en mesure de les résoudre automatiquement (mais donner -xinversera le chiffrement)


Puisqu'il s'agit d'un catalogue, les langues créées après ce défi sont autorisées à concourir. Notez qu'il doit y avoir un interprète pour que la soumission puisse être testée. Il est permis (et même encouragé) d'écrire cet interprète vous-même pour une langue non implémentée auparavant. En dehors de cela, toutes les règles standard du code-golf doivent être respectées. Les soumissions dans la plupart des langues seront notées en octets dans un codage préexistant approprié (généralement UTF-8).

Catalogue

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) en tant que liste des solutions les plus courtes par langue et b) en tant que classement général.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

## Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

## [<><](https://esolangs.org/wiki/Fish), 121 bytes

Afficher l'extrait de code

code-golf  string  cipher 
— Bleu
source
8
"Vous pourriez même le faire comme une tâche à faire. Si c'est le cas, veuillez ne pas copier ces réponses, votre professeur ne veut certainement pas quelque chose comme les réponses ici ." Je me demande ce qui se passerait si vous remettiez à un professeur une poignée de 90 octets de caractères en désordre et de raccourcis ...
— ASCIIThenANSI

Réponses:

9

Pyth, 13 octets

uXGH.<HQrBG1z

Suite de tests

Fondamentalement, nous commençons par les deux chaînes que nous voulons déplacer par césar, les alphabets minuscules et majuscules. La liste contenant ces deux éléments est générée par rBG1, bifurquer en majuscules. Ensuite, nous réduisons cette liste, en commençant par la chaîne d'entrée et en traduisant d'abord les lettres minuscules, puis les lettres majuscules par le décalage approprié.

— isaacg
source
Très bien, j'oublie toujours que la bifurcation existe ...: P
— FryAmTheEggman
5

Forfait Bash + BSD-Games, 21

caesar $[($1+130)%26]

Builtins FTW! Ressemble presque à Mathematica. Les réponses Pyth sont cependant encore plus courtes.

Chaîne d'entrée lue depuis STDIN et entier depuis la ligne de commande. par exemple:

$ ./caesar.sh 13 <<< "Spam spam spam sausage and spam!"
Fcnz fcnz fcnz fnhfntr naq fcnz!
$

Ou si vous n'aimez pas la fonction intégrée:

Bash + coreutils, 63

printf -va %s {a..z}
t=${a:$1%26}${a:0:$1%26}
tr A-Z$a ${t^^}$t
— Traumatisme numérique
source
Il me semble que la version coreutils ne fonctionne pas avec -127 et / ou 127?
— Neil
@Neil Oui. Bonne prise. Fixé.
— Digital Trauma
5

JavaScript (ES6), 122 118 114 111 octets

alert((p=prompt)().replace(/[a-z]/gi,c=>String.fromCharCode((x=c.charCodeAt(),a=x&96,x-a+n+129)%26-~a),n=+p()))

4 octets enregistrés grâce à @Neil !

Explication

La première invite prend la chaîne d'entrée. Le second est le nombre de décalage de chaque lettre.

alert(
  (p=prompt)()              // get input string
    .replace(/[a-z]/gi,c=>  // for each letter
      String.fromCharCode((
        x=c.charCodeAt(),   // x = code of character
        a=x&96,             // a = index of letter a (-1) in same capitalisation
        x-a+n+129)%26-~a    // add N to the letter code and wrap at 26
      ),                    // (+129 is needed to make the % work with negative numbers)
      n=+p()                // get number to shift by
    )
)
— user81655
source
1
Très agréable! Mais cela ne fonctionne pas sur toutes les entrées; essayez "abcdefg", -26. Cela peut être résolu en modifiant la formule en (x-a+n+130)%26.
— ETHproductions
@ETHproductions Merci d'avoir attrapé ça!
— user81655
"Vous devez créer un programme complet, pas seulement une fonction ou un extrait"
— LegionMammal978
@ LegionMammal978 Merci, je ne l'ai pas remarqué.
— user81655
Ça a=x&96,(x-a+n+129)%26+a+1aide?
— Neil
3

CJam, 34 22 21 20 octets

Merci à FryAmTheEggman pour avoir économisé 1 octet.

l'[,_el^_26/l~fm<ser

Testez-le ici.

L'entrée est la chaîne à changer sur la première ligne et le décalage sur la seconde.

Explication

l    e# Read the first line of input.
'[,  e# Push a string with all ASCII characters up to and including Z.
_el  e# Duplicate and convert to lower case. This only affects the letters.
^    e# Symmetric set-difference: except for the letters, each character appears in both
     e# sets and will be omitted from the difference, but all the letters will be included.
     e# This gives us "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
_26/ e# Duplicate and split into chunks of 26 characters, separating lower and upper case.
l~   e# Read the second line of input and evaluate.
fm<  e# Shift each of the two substrings by that many characters to the left.
s    e# Convert to a single string, joining both substrings back together.
     e# On the stack are now the input, the letters in alphabetical order and the letters
     e# in shifted order.
er   e# Character transliteration: replace each occurrence of a letter with the character
     e# at the corresponding position in the shifted string.
— Martin Ender
source
@FryAmTheEggman The '[,_el^est un conseil de Dennis. Je ne sais pas ce que vous voulez dire fcependant, cela semble être une utilisation assez normale?
— Martin Ender
Je suppose que je n'ai tout simplement pas lu suffisamment de réponses CJam: P Il semble vraiment bien de l'utiliser comme une carte mais de changer l'ordre des arguments.
— FryAmTheEggman
@FryAmTheEggman en fait, je n'en ai pas du tout besoin @. :)
— Martin Ender
2

Java, 249 octets

C'est aussi court que possible. La lecture de stdin consomme une tonne d'octets. Une solution utilisant des arguments de ligne de commande est sensiblement plus courte mais, cette tâche a spécifié stdin pour l'entrée.

Le format d'entrée est la chaîne d'abord suivie du numéro de décalage sur une nouvelle ligne.

interface C{static void main(String[]a){java.util.Scanner r=new java.util.Scanner(System.in);String s=r.nextLine();int i=(r.nextInt()+26)%26;s.chars().forEach(c->System.out.print((char)(c>64&c<91|c>96&c<123?c<91?65+(c+i-65)%26:97+(c+i-97)%26:c)));}}

En utilisant des arguments de ligne de commande, cette solution ne fait que 188 octets. L'entrée est la chaîne comme premier argument et le décalage comme deuxième.

interface C{static void main(String[]a){int i=(Integer.parseInt(a[1])+26)%26;a[0].chars().forEach(c->System.out.print((char)(c>64&c<91|c>96&c<123?c<91?65+(c+i-65)%26:97+(c+i-97)%26:c)));}}
— ankh-morpork
source
1

R, 111 octets

code

n=scan();s=scan(,"");for(l in as.numeric(sapply(s,charToRaw))){v=97;if(l<97)v=65;cat(intToUtf8((l+n-v)%%26+v))}

non golfé

n <- scan()                           # input integer
s <- scan(,"")                        # input string letter by letter
z <- as.numeric(sapply(s,charToRaw))  # get ASCII index of character
for (l in z){                         # loop through chars
  v=97                                # base index of not capitalized chars
  if(l<97)v=65                        # base index of capitalized chars
  cat(intToUtf8((l+n-v)%%26+v))       # paste the char of the shifted index
}

Ce programme prend l'entrée utilisateur de STDIN, d'abord le shifter entier puis la chaîne, caractère par caractère.

— Mutador
source
1

Perl, 81 octets

(+1 pour le -pdrapeau)

s/[^ ]+ //;$n=$&%26;eval"y/a-zA-Z/".($x=chr(97+$n)."-za-".chr$n+96).uc$x."/"if$n

Toujours en train de jouer au golf ...

Tester:

llama@llama:...code/perl/ppcg67044caesar$ printf '1 abcdefghijklmnopqrstuvwxyz\n13 Spam spam spam sausage and spam!\n52 abcdefghijklmnopqrstuvwxyz\n-1 abcdefghijklmnopqrstuvwxyz\n3 ABCxyz' | perl -p caesar.pl; echo
bcdefghijklmnopqrstuvwxyza
Fcnz fcnz fcnz fnhfntr naq fcnz!
abcdefghijklmnopqrstuvwxyz
zabcdefghijklmnopqrstuvwxy
DEFabc
— Poignée de porte
source
1

Python 2, 163 160 octets

Je ne sais pas si je peux encore jouer au golf.

import sys;k=sys.argv
def f(x,n):r=chr((ord(x.lower())-97+n)%26+97);return(x,[r,r.upper()][x.isupper()])
print''.join(f(x,int(k[2]))[x.isalpha()] for x in k[1])

Puisqu'il est assez illisible, voici une version non golfée:

import sys

def shift(x,n):
    # shift character x by n (all in lowercase)
    r = chr((ord(x.lower())-97+n)%26+97)
    if x.isalpha() and x.islower():
        return r
    elif x.isalpha() and x.isupper():
        return r.upper()
    else:
        return x

# 'map' the function shift to each character of the input   
output = ''.join(shift(x,int(sys.argv[2])) for x in sys.argv[1])
print(output)

Concernant l'entrée: Il attend deux arguments, le premier doit être une chaîne et le second un entier (la quantité de décalage). Exemples (le fichier est appelé csr.py):

$ python csr.py gnu 9
pwd
$ python csr.py "Spam spam spam sausage and spam\!" 13
Fcnz fcnz fcnz fnhfntr naq fcnz!

Remarque: Dans le deuxième exemple, un caractère d'échappement et ""sont nécessaires

— ბიმო
source
1

Python 2, 118 116 octets

s,n=input()
print''.join([[c,chr((ord(c)-97+n)%26+97)]['`'<c<'{'],chr((ord(c)-65+n)%26+65)]['@'<c<'[']for c in s)
— TFeld
source
Vous souhaiterez peut-être utiliser des listes au lieu des if/elseinstances ( codegolf.stackexchange.com/a/62/36885 ). Par exemple, print''.join([[c,chr((ord(c)-97+n)%26+97)]['~'<c<'{'],chr((ord(c)-65+n)%26+65)]['@'<c<'[']for c in s)est un peu plus court et devrait fonctionner de la même manière. (Sauf changer le tilde en un backtick comme vous l'avez fait auparavant - je n'ai pas pu obtenir le backtick pour qu'il s'affiche correctement.)
— mathmandan
1

Mathematica, 117 octets

Echo[InputString[]~StringReplace~Thread[Join[a=Alphabet[],b=ToUpperCase@a]->(c=RotateLeft)[a,d=Input[]]~Join~c[b,d]]]

Prend la chaîne, suivie d'une nouvelle ligne, suivie du facteur de décalage. Pourrait encore être golfable ...

— LegionMammal978
source
1

Perl 6 , 73 + 1 = 74 octets

$ perl6 -pe 's:g:i/<[a..z]>/{chr ((my$o=ord ~$/)-(my$a=$o+&96+1)+BEGIN get%26)%26+$a}/' # 73+1

La première ligne de saisie est le nombre de caractères pour déplacer les lettres vers le haut.

Usage:

$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'1
abcdefghijklmnopqrstuvwxyz'
bcdefghijklmnopqrstuvwxyza
$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'13
Spam spam spam sausage and spam!'
Fcnz fcnz fcnz fnhfntr naq fcnz!
$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'52
abcdefghijklmnopqrstuvwxyz'
abcdefghijklmnopqrstuvwxyz
$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'-1
abcdefghijklmnopqrstuvwxyz'
zabcdefghijklmnopqrstuvwxy
$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'3
ABCxyz'
DEFabc
$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'1000000000000000000000000000000000000000
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ'
mnopqrstuvwxyzabcdefghijkl
MNOPQRSTUVWXYZABCDEFGHIJKL
— Brad Gilbert b2gills
source
1

C ++, 163 154 152 octets

#include<cstdio>
#include<cstdlib>
int main(int x,char**a){for(int c,b,s=atoi(a[1]);1+(c=getchar());putchar(c<b|c>b+26?c:(c+s-b+26)%26+b))b=c<97?65:97;}

Usage:

$ ./caesar -1 <<< "123 a A z Z aBcDeFgHiKlMnOpQrStUvWxYz"
123 z Z y Y zAbCdEfGhJkLmNoPqRsTuVwXy
— Simon D.
source
0

k4, 80 octets

Le programme accepte le numéro de décalage comme argument de ligne de commande et lit le texte de stdin.

En raison d'une contrainte technique, les décalages négatifs doivent être codés avec un trait de soulignement au lieu d'un trait d'union moins. (Sans l'analyseur pour interpréter ce codage, la solution serait de 64 octets.)

% wc -c c.k
80 c.k
% cat c.k
c:{x;,/x{y!(x_y),x#y}'.Q`a`A}
.z.pi:{1@x^c[.q.mod[.*{x^((!).$"_-")x}.z.x]26]x;}
%

Voici les exemples exécutés:

% echo abcdefghijklmnopqrstuvwxyz|q c.k 1
bcdefghijklmnopqrstuvwxyza
% echo 'Spam spam spam sausage and spam!'|q c.k 13
Fcnz fcnz fcnz fnhfntr naq fcnz!
% echo abcdefghijklmnopqrstuvwxyz|q c.k 52
abcdefghijklmnopqrstuvwxyz
% echo abcdefghijklmnopqrstuvwxyz|q c.k _1
zabcdefghijklmnopqrstuvwxy
% echo ABCxyz|q c.k 3
DEFabc
%

Et voici un petit harnais de test stupide qui vérifie à la fois l'encodage et le décodage. (C'est zsh; pour bashou ksh, changez l' forindexation de boucle en ((i=0;i<5;i++)). Tableaux à base unique, ugh ....)

% a=(abcdefghijklmnopqrstuvwxyz 'Spam spam spam sausage and spam!' abcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstuvwxyz ABCxyz)
% b=(1 13 52 _1 3)
% c=(bcdefghijklmnopqrstuvwxyza 'Fcnz fcnz fcnz fnhfntr naq fcnz!' abcdefghijklmnopqrstuvwxyz zabcdefghijklmnopqrstuvwxy DEFabc)
% for ((i=1;i<=5;i++))
for> do
for>     r=$(echo "${a[i]}"|q c.k "${b[i]}")
for>     s=$(echo "$r"|if [[ ${b[i]} == _* ]]; then q c.k "${b[i]/_}"; else q c.k "_${b[i]}"; fi)
for>     printf '%s\t%s\n' "$([[ ${c[i]} == $r ]] && echo good || echo bad)" "$([[ ${a[i]} == $s ]] && echo good || echo bad)"
for> done
good    good
good    good
good    good
good    good
good    good
%
— Aaron Davies
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.