Cambio César

22

Un cambio de César es probablemente algo con lo que todos estamos familiarizados.

(Puede que incluso lo esté haciendo como tarea de tarea. Si es así, por favor no copie estas respuestas, su maestro seguramente no quiere nada como las respuestas aquí).

En caso de que no lo estés, un cambio César es una forma muy simple de cifrado. Se necesita una cadena para ser cifrada y un número entero. Luego, para cada carácter alfabético en la cadena, realice la siguiente transformación:

  1. Calcula la posición del personaje en el alfabeto (basado en 0).
  2. Agregue a ese número el entero recibido al principio.
  3. Si bien el número es mayor que 25, resta 26 de él.
  4. Calcule la posición del alfabeto en el que se encuentra.

Deje el resto de los personajes sin cambiar.

Las letras mayúsculas deben respetarse porque ¿qué es el inglés sin mayúsculas?

Ejemplos:

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

Supuestos

  • Puede recibir cualquier carácter ASCII imprimible
  • El número de entrada puede ser negativo y siempre será mayor que -128 y menor que 128 ( -128<x<128)
  • Debe poder codificar letras mayúsculas y no mayúsculas de forma reversible.
  • Debe crear un programa completo, no solo una función o fragmento
  • Obtendrá su opinión de STDIN o la alternativa más cercana
  • Puede elegir el formato para su entrada, indíquelo en su respuesta

  • Los caracteres que deben desplazarse son puntos de código ASCII 0x41 - 0x5Ay 0x61-0x7A- letras mayúsculas y minúsculas

    • Las letras mayúsculas deben permanecer mayúsculas
    • Las letras minúsculas deben permanecer más bajas
    • Los caracteres que no están en este rango deben dejarse como están

  • Tenga en cuenta que para este desafío, solo tiene que cifrar las cadenas, no tiene que ser capaz de resolverlas automáticamente (pero dar -xinvertirá el cifrado)


Como se trata de un catálogo, los idiomas creados después de este desafío pueden competir. Tenga en cuenta que debe haber un intérprete para que se pueda probar el envío. Está permitido (e incluso alentado) escribir este intérprete usted mismo para un lenguaje previamente no implementado. Aparte de eso, se deben obedecer todas las reglas estándar del golf de código . Las presentaciones en la mayoría de los idiomas se puntuarán en bytes en una codificación preexistente apropiada (generalmente UTF-8).

Catalogar

El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

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

Mostrar fragmento de código

code-golf  string  cipher 
— Azul
fuente
8
"Incluso podría hacerlo como tarea de tarea. Si es así, por favor no copie estas respuestas, su maestro seguramente no quiere nada como las respuestas aquí ". Me pregunto qué pasaría si se entregó un profesor de un kludge 90 bytes de caracteres desordenados y los accesos directos ...
— ASCIIThenANSI

Respuestas:

9

Pyth, 13 bytes

uXGH.<HQrBG1z

Banco de pruebas

Básicamente, comenzamos con las dos cadenas que queremos desplazar por césar, los alfabetos en minúsculas y mayúsculas. La lista que contiene ambos es generada por rBG1bifurcado en mayúsculas. Luego, reducimos esta lista, comenzando con la cadena de entrada y traduciendo primero las letras minúsculas y luego las mayúsculas por el cambio apropiado.

— isaacg
fuente
Muy bien, sigo olvidando que existe la bifurcación ...: P
— FryAmTheEggman
5

Paquete Bash + bsd-games, 21

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

Construido FTW! Casi se siente como Mathematica. Sin embargo, las respuestas de Pyth son aún más cortas.

Cadena de entrada leída desde STDIN y entero desde la línea de comandos. p.ej:

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

O si no te gusta el incorporado:

Bash + coreutils, 63

printf -va %s {a..z}
t=${a:$1%26}${a:0:$1%26}
tr A-Z$a ${t^^}$t
— Trauma digital
fuente
¿Me parece que la versión coreutils no funciona con -127 y / o 127?
— Neil
@Neil Sí. Buena atrapada. Fijo.
— Trauma digital
5

JavaScript (ES6), 122 118 114 111 bytes

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

¡Guardado 4 bytes gracias a @Neil !

Explicación

El primer mensaje toma la cadena de entrada. El segundo es el número para cambiar cada letra.

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
    )
)
— usuario81655
fuente
1
¡Muy agradable! Pero no funciona en todas las entradas; tratar "abcdefg", -26. Esto se puede solucionar cambiando la fórmula a (x-a+n+130)%26.
— ETHproductions
@ETHproductions ¡Gracias por atrapar eso!
— user81655
"Debe crear un programa completo, no solo una función o fragmento"
— LegionMammal978
@ LegionMammal978 Gracias, no me di cuenta de eso.
— user81655
Ciervas a=x&96,(x-a+n+129)%26+a+1ayuda?
— Neil
3

CJam, 34 22 21 20 bytes

Gracias a FryAmTheEggman por guardar 1 byte.

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

Pruébalo aquí.

La entrada es la cadena que se desplazará en la primera línea y el desplazamiento en la segunda.

Explicación

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
fuente
@FryAmTheEggman The '[,_el^es un consejo de Dennis. Sin fembargo, no sé a qué te refieres , ¿parece un uso bastante normal?
— Martin Ender
Supongo que no he leído suficientes respuestas de CJam: P Parece realmente genial usarlo como un mapa pero cambiar el orden de los argumentos.
— FryAmTheEggman
@FryAmTheEggman en realidad, no necesito @nada. :)
— Martin Ender
2

Java, 249 bytes

Esto es lo más corto que pude obtener. La lectura de stdin consume una tonelada de bytes. Una solución que usa args de línea de comando es notablemente más corta pero, esta tarea especificó stdin para entrada.

El formato de entrada es la Cadena seguida primero por el número de turno en una nueva línea.

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

Usando argumentos de línea de comando, esta solución tiene solo 188 bytes. La entrada es la Cadena como primer argumento y el cambio como el segundo.

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
fuente
1

R, 111 bytes

código

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

sin 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
}

Este programa toma la entrada del usuario de STDIN, primero el desplazador de números enteros y luego la cadena, carácter por carácter.

— Mutador
fuente
1

Perl, 81 bytes

(+1 para la -pbandera)

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

Todavía estoy trabajando en jugar golf ...

Prueba:

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
— Pomo de la puerta
fuente
1

Pitón 2, 163 160 bytes

No estoy seguro si todavía puedo jugar 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])

Dado que es bastante ilegible, aquí hay una versión sin golf:

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)

En cuanto a la entrada: espera dos argumentos, el primero debe ser una cadena y el segundo un número entero (la cantidad de desplazamiento). Ejemplos (se llama archivo csr.py):

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

Nota: en el segundo ejemplo, ""se necesita un carácter de escape

— ბიმო
fuente
1

Python 2, 118116 bytes

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
fuente
Es posible que desee utilizar listas en lugar de las if/elseinstancias ( codegolf.stackexchange.com/a/62/36885 ). Por ejemplo, print''.join([[c,chr((ord(c)-97+n)%26+97)]['~'<c<'{'],chr((ord(c)-65+n)%26+65)]['@'<c<'[']for c in s)es un poco más corto y debería funcionar igual. (Excepto el cambio de la tilde a un acento grave como que tenía antes - no pude conseguir el acento grave a pantalla derecha.)
— mathmandan
1

Mathematica, 117 bytes

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

Toma la secuencia, seguida de una nueva línea, seguida del factor de desplazamiento. Todavía podría ser golfable ...

— LegionMammal978
fuente
1

Perl 6 , 73 + 1 = 74 bytes

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

La primera línea de entrada es el número de caracteres por los que se desplazan las letras hacia arriba.

Uso:

$ 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
fuente
1

C ++, 163 154 152 bytes

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

Uso:

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

k4, 80 bytes

El programa acepta el número de turno como un argumento de línea de comandos y lee el texto de stdin.

Debido a una restricción técnica, los desplazamientos negativos deben codificarse con un guión bajo en lugar de un guión menos. (Sin el analizador para interpretar esta codificación, la solución sería de 64 bytes).

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

Aquí están los ejemplos ejecutados:

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

Y aquí hay un pequeño arnés de prueba que verifica tanto la codificación como la decodificación. (Esto es zsh; para basho ksh, cambie la forindexación del bucle a ((i=0;i<5;i++)). Matrices basadas en uno, 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
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.