Entrada estándar de transformación ROT-13

34

El desafío: leer una entrada de longitud arbitraria y producir el ROT13 de la entrada. Todos los caracteres, además de AZ, deben copiarse literalmente a la salida, y el caso debe conservarse si es posible.

Cualquier lenguaje que pueda leer y escribir transmisiones estándar es un juego justo.

code-golf  cryptography 
— MiffTheFox
fuente
3
El problema no debería ser una etiqueta, así que eliminé ROT13, solo un FYI
— Nick Berardi
2
¿No te refieres a A-Za-z (para contar mayúsculas y minúsculas)?
— Joey Adams
55
@ Chris Jester-Young, pertenece a esta categoría en wikipedia. Es parte de la criptografía, pero no la más difícil. De todos modos, ya no estoy siguiendo este sitio. La comunidad me decepcionó. Lo siento. GL HF.
— Nakilon
17
Decir que xor no es cifrado es como decir que a + b no es matemática .
— Nakilon
3
Las etiquetas se utilizan para clasificar preguntas y ayudar a buscar preguntas similares. La etiqueta de criptografía (del griego kryptós, "oculto, secreto" y graphein, "escritura") en particular es para problemas de cifrado y descifrado. Todo el cifrado y descifrado, no solo los que son seguros para las aplicaciones modernas.
— Angs

Respuestas:

25

Bash, 23 bytes

Respuesta canónica de 23 caracteres:

tr A-Za-z N-ZA-Mn-za-m
— Chris Jester-Young
fuente
1
No tengo acceso a bash en este momento, pero creo que esto debería funcionar: tr A-za-m N-ZA-z(16 caracteres)
— Nabb
2
@Nabb: ¡Me alegro de verte, GolfScript-meister! : -DI creo que su solución aquí rompería la estipulación de que "Todos los caracteres, además de AZ, deben copiarse al pie de la letra".
— Chris Jester-Young
@ Chris: Sí, parece que tienes razón.
— Nabb
@Nabb: No, para mí parece que está equivocado. ¿O puedes mostrar un ejemplo?
— Usuario desconocido
2
@user unknown: escriba [\\]^_`la entrada. Volverá en NOPQRSlugar de [\\]^_`, al menos en la versión de trI have. (Esos son los seis personajes en ASCII que se encuentran entre Zy a. Obviamente, todos los demás personajes funcionarán correctamente.)
— Chris Jester-Young
20

Bash - 5 caracteres

rot13

 

— gnibbler
fuente
18
Dos votos negativos hasta ahora (sin comentarios), pero no hay votos negativos para la pregunta. Supongo que eso significa que está bien preguntar a los codegolf triviales pero no dar la respuesta trivial. ¡ Codegolfs más duros por favor!
— gnibbler
8
¿Qué versión bash? No tengo una rotura incorporada13. bash --version GNU bash, Version 4.0.33(1)-release (i486-pc-linux-gnu)
— usuario desconocido
12
rot13 - 0 chars
— Hubiera
2
es coreutils mi amigo, no Bash
— TheDoctor
3
erm ... no. my bash (Ubuntu 13.10) dice "comando no encontrado, puedes instalar este programa antes de sudo apt-get install bsdgames"
17

Python 2, 34 bytes

print raw_input().encode('rot13')
— Juan
fuente
1
-1 Creo que es una trampa que estés usando una biblioteca integrada.
— Glenn Nelson el
16
Los he usado en todos los códigos de golf en los que participé ... Además, si usar lib estándar de python es hacer trampa, ¿cómo está usando tr not?
— Juan
3
@Anon En cualquier caso, es una respuesta que simplemente ignoras. No está fuera del objetivo, no hay reglas establecidas por el OP ni por la comunidad. Claro, tal vez la mía no sea una solución galardonada, como la que usa tr que patea el culo. Pero no es una broma, estoy aprovechando el poder de Python para reducir el conteo, como lo haría cualquier otro.
— Juan
2
@Glenn: por el contrario, nunca he visto una cosa de código de golf que lo diga. Tampoco codegolf.com, golf.shinh.org o SPOJ SHORTEN.
— hallvabo
99
@ Glenn, creo que las funciones de la biblioteca son un juego justo. Depende de la cuestión del golf ser lo suficientemente interesante como para no estar en la biblioteca de nadie o excluirlo específicamente.
— gnibbler
15

Befunge - 7x30 = 210 6x26 = 156 caracteres

Nueva versión de transmisión que admite mayúsculas y minúsculas y debe admitir entradas ilimitadas.

v,<               <<     <
  ^-4-9<    >:"A"\`|
     >:"a"\`|     #>:"Z"`|
>~:0`| #    >:"z"`|
,    @ |    <`"m":<v`"M":<
^  +4+9<    ^      <

La versión anterior

Esto almacena los valores dentro de su propio código fuente. Realmente muestra cuán horrible es tratar de generar valores almacenados en el mismo orden en que los recibe. Solo admite caracteres en minúscula.

vp0p11:+1g11<      < <
v                    ^-4-9<
v    >:"a"\`|>:"z"`|>:"m"`|
>~:0`|      >^     >^#
                     ^+4+9<
     >$011g1+0p>12g1+:12p0g:v
               ^           ,_@

No estoy seguro exactamente qué limitaciones tiene esto, usando http://www.quirkster.com/iano/js/befunge.html como el intérprete, parece que se rompe con entradas grandes.

— Nemo157
fuente
Puede eliminar el espacio en blanco al final de las líneas.
— Zacharý
10

Rubí - 60 57 38 37 caracteres

Editar: Y acabo de darme cuenta de que las cadenas de Ruby tienen un trmétodo.

puts$<.read.tr'A-Za-z','N-ZA-Mn-za-m'

Prueba

input = "The challenge: To read an input of arbitrary length and produce the ROT13 of the input. All characters besides A-Z should be copied to the output verbatim, and case should be preserved if possible.

Any language that can read and write standard streams is fair game."

output = `echo '#{input}' | ruby golf-rot13.rb`

puts "Input:"
puts input
puts "-------"
puts "Output:"
puts output

Da:

Input:
The challenge: To read an input of arbitrary length and produce the ROT13 of the input. All characters besides A-Z should be copied to the output verbatim, and case should be preserved if possible.

Any language that can read and write standard streams is fair game.
-------
Output:
Gur punyyratr: Gb ernq na vachg bs neovgenel yratgu naq cebqhpr gur EBG13 bs gur vachg. Nyy punenpgref orfvqrf N-M fubhyq or pbcvrq gb gur bhgchg ireongvz, naq pnfr fubhyq or cerfreirq vs cbffvoyr.

Nal ynathntr gung pna ernq naq jevgr fgnaqneq fgernzf vf snve tnzr.
— Nemo157
fuente
No necesitas el espacio después puts, y 'Az' es un atajo para 'A-Za-z'
— Ventero
1
@Ventro: Gracias, después de un poco de prueba parece 'A-z'que en realidad es 'A-Z[\]^_a-z ' , damn ascii having characters between Z` y a.
— Nemo157
1
Esencialmente las mismas, pero 35 caracteres: puts gets.tr'A-Za-z','N-ZA-Mn-za-m'.
— Michael Kohl el
@Michael: Excepto getssolo devuelve la primera línea, usando $ <. Lecturas de lectura hasta EOF. La pregunta no dice nada sobre si la entrada puede contener nuevas líneas, así que me equivoqué por el lado de la precaución.
— Nemo157
Es justo, pero como la especificación del ejercicio solo menciona la "longitud arbitraria" pero no dice nada acerca de las nuevas líneas, prefiero equivocarme por el lado de la brevedad en codegolf ;-)
— Michael Kohl
10

vim, 5 pulsaciones de teclas

Asumiendo el modo normal y que el texto ya está escrito en el búfer:

ggg?G

O, siguiendo las convenciones de vimgolf:

g?GZZ

También puede invocarlo como un comando de terminal, algo como esto:

$ vim -c 'norm g?G' -
< your text here ...
... multiple lines if you want ...
... terminate input with ctrl+D on a blank line >

Supongo que este último contaría como un "programa" de 8 caracteres ( norm g?G)

— daniero
fuente
norm g?Ges la abreviatura de normal g?Geso hace 8 caracteres.
— Patrick Oscity
Creo que puede asumir con seguridad que comienza en la línea 1, por lo que ggpuede dejar el primero . Yo diría 3 pulsaciones de teclas cuando el archivo está abierto.
— Patrick Oscity
1
Si utilizamos las convenciones de vimgolf (comienza en un vim de vainilla que acaba de abrir el archivo, pero necesita guardar y salir) también obtenemos 5 ( g?GZZ).
— FireFly
7

C - 83 79 caracteres

main(c,b){while((c=getchar())>=0)b=c&96,putchar(isalpha(c)?b+1+(c-b+12)%26:c);}

Versión legible:

#include <ctype.h>
#include <stdio.h>

int main(void)
{
    int c, base;

    while ((c = getchar()) >= 0) {
        if (isalpha(c)) {
            base = (c & 96) + 1; /* First letter of the upper or lower case. */
            c = base + (c - base + 13) % 26;
        }
        putchar(c);
    }

    return 0;
}
— Joey Adams
fuente
1
¿Incluye los encabezados que incluye en su recuento?
— JPvdMerwe
@JPvdMerwe: No incluí ningún encabezado en la versión de golf, ni necesitaba hacerlo.
— Joey Adams
Puede usar el operador de coma antes de putchar para quitar un par de llaves.
— Alexandru
¿Podría explicar main (c, b)? Es la primera vez que veo esto.
— Alexandru
2
@Alexandru la mayoría de los compiladores de C admiten main con cualquier parámetro. Además, el estándar C original define que un argumento sin tipo es un int. Por lo tanto, puede declarar ints sin realmente escribir int.
— Juan
7

Python (117 bytes)

Aquí hay una versión de Python que evita el rot13()método.

import sys
print"".join([chr(x/32*32+1+(x%32+12)%26if 64<x<91or 96<x<123 else x)for x in map(ord,sys.stdin.read())])
— JPvdMerwe
fuente
raw_input devuelve una línea, no todas las entradas.
— Alexandru
Necesitas import sysy usas sys.stdin.read().
— Alexandru
@Alexandru: lo hará
— JPvdMerwe
-2 bytes si elimina el []para hacer la lista comp un generador: tio.run/…
— connectyourcharger
7

tr///solución en Perl (39 caracteres), la repetitiva se puede eliminar con -p:

while(<>){y/a-zA-Z/n-za-mN-ZA-M/;print}

Uso -p(23 caracteres, incluido el interruptor adicional):

perl -pe'y/a-zA-Z/n-za-mN-ZA-M/'
— Luego.
fuente
Agregue 1 char para el p, pero retire la placa repetitiva.
— JB
7

R, 37 bytes

example("chartr");cat(rot(scan(,"")))

example("chartr")ejecuta los ejemplos para chartr, que incluye la rotfunción, que es ROT13por defecto ...

— mnel
fuente
5

DC ( 111 108 para el propio DC)

Ok, aquí está en (principalmente) dc y algo de magia sed y od para llevarlo al formato correcto para el código. Si no cuenta lo de entrada ( echo -n MESSAGE |) son 160 bytes:

od -An -t dC|sed 's/^\ *//;s/\ \{2,3\}/\n/g'|dc -e'[13+26%]sm[65-lmx65+]su[97-lmx97+]sl[96<b64<dPc]sa[91>c]sd[123>e]sb[lux]sc[llxdd]se[ddddlaxlrx]sy[?z0<y]dsrx'

Como punto de interés, el programa de CC en sí tiene solo 108 bytes de longitud, más corto que la versión de Python que no es de biblioteca. ¡Incluso conserva mayúsculas y minúsculas, y supera a Javascript en el envío anterior! Si solo pudiera analizar mejor la salida de od, o mejor aún, reemplazarla por completo.

EDITAR: Vale la pena señalar que la pregunta no indica una nueva línea final 10Pque me ahorra tres bytes más.

EDIT 2: no hay una especificación para el formato de la entrada, por lo que supongo que se toma como conveniente para mi programa: P

— Hiato
fuente
5

Befunge-93, 85 (cuadrícula: 41x3 = 123)

Esta es una pregunta antigua, pero pensé en revivirla para publicar una respuesta Befunge un poco más agradable.

#v_~::" "/2%" "*-::"@"`!#v_"Z"#v`#!_1
v> "M"`2*1\-34*1+*+    1:>$!   _:"."-!#@_
>,^

Puedes probarlo aquí . Ingrese un solo carácter a la vez; termina al ingresar un .carácter (puede cambiarlo modificando el "."lado cercano a la derecha de la segunda fila). Funciona con mayúsculas y minúsculas, así como con puntuación y sin límite de entrada.

No espero que esto obtenga un montón de votos a favor ni nada, pero solo quería demostrar lo increíble que es Befunge en realidad que puedes hacerlo un poco mejor que la otra respuesta.

Probablemente podría hacerlo aún más corto en Befunge-98.

— Kasran
fuente
Puede agregar mi fragmento desde aquí para tener un intérprete en línea, si lo desea. :)
— Ingo Bürk
Ooh, todavía no he investigado fragmentos. Voy a echar un vistazo, gracias!
— Kasran
Esto no funciona si hay un espacio en la entrada. Entra en un bucle infinito en la secuencia >$! _porque tienes dos ceros en la pila en ese punto cuando esperas un valor distinto de cero.
— James Holderness
4

PHP - 103 98 80 caracteres

(sin usar str_rot13 ())

<?=preg_replace('#[a-zA-Z]#e','chr(($x=ord("\0"))-$x%32+1+($x%32+12)%26)',`cat`);
— Arnaud Le Blanc
fuente
4

Delphi, 110

var c:Char;begin repeat Read(c);Write(Chr(Ord(c)+(Ord(c in['A'..'M'])-Ord(c in['N'..'Z']))*13));until EOF;end.
— PatrickvL
fuente
var c:Char;begin repeat Read(c);Write(Chr(Ord(c)+(Ord(c in['A'..'M'])-Ord(c in['N'..'Z']))*13));until EOF;end.salva un personaje :)
— Wouter van Nifterick
@Wouter van Nifterick: ¡Buen lugar! Lo actualizaré en consecuencia
— PatrickvL
4

Haskell, 100 personajes

a%b=([a..b]++)
main=interact$map$toEnum.((0%64$78%90$65%77$91%96$110%122$97%109$[123..])!!).fromEnum
— MtnViewMark
fuente
3

Java 251 caracteres

public class r{public static void main(String[] a){String s = a[0];for(int i=0;i<s.length();){char c=s.charAt(i++);if(c>='a'&&c<='m')c+=13;else if(c>='n'&&c<='z')c-= 13;else if(c>='A'&&c<='M')c+=13;else if(c>='A'&&c <='Z')c-=13;System.out.print(c);}}}
— Clyde Lobo
fuente
3

Pitón 3 (107)

Ok, prometo dejar de responder esta pregunta ahora, pero me sentí obligado a superar la respuesta de DC en Python. Esto probablemente se refleja mal en mí como persona :).

import sys;[print(x.isalpha()and chr((ord(x)&96)+1+(ord(x)%32+12)%26)or x,end='')for x in sys.stdin.read()]
3

C: 69 68 caracteres

Bien, sé que este hilo está muerto hace mucho tiempo, pero no podía soportar la solución C (larga) que ni siquiera se compila en Clang (pero sí en GCC).

main(c){putchar(isalpha(c=getchar())*((c|32)<110?13:-13)+c);main();}

Probablemente es casi todavía exprimible. Ciertamente fue exprimible. Y no solo era exprimible, sino que era posible hacerlo recursivo.

— Fors
fuente
3

05AB1E , 13 12 bytes

Guardado un byte gracias a robbie0630

ADu)øJD2äRJ‡

Pruébalo en línea!

Explicación

ADu           # push lower-case and uppercase alphabet
   )øJ        # zip, flatten and join, producing aAbB..zZ
      D2äRJ   # split a copy in 2 pieces, reverse and join producing nNoO..mM
           ‡  # translate input by replacing members of the alphabet 
              # with the corresponding member of the rot-13 alphabet
              # implicitly display
— Emigna
fuente
Me encontré con esto --debug, y parece que ˜es un no-op en este caso y se puede cortar.
— robbie
@ robbie0630: Cierto. No tengo idea de por qué tuve eso. Gracias :)
— Emigna
2

JavaScript 1.8, 106

alert(prompt().replace(/\w/g,function(c)String.fromCharCode(c.charCodeAt()+(c.toLowerCase()<'n'?13:-13))))

JavaScript, 115

alert(prompt().replace(/\w/g,function(c){return String.fromCharCode(c.charCodeAt()+(c.toLowerCase()<'n'?13:-13))}))

Esta solución resuelve el problema agregando 13 al código de caracteres si el carácter en cuestión está en la primera mitad del alfabeto, o restando 13 si está en la segunda mitad.

— Casey Chu
fuente
Puede guardar 7 caracteres reemplazándolos +(c.toLowerCase()<'n'?13:-13))con -13+26*/[a-m]/i.test(c).
— Jacob
2

CHIQRSX9 + , 1

R

Solo tiene que usar la herramienta adecuada para el problema.
CHIQRSX9 + es Turing completo, y puede leer y escribir desde canales estándar con C.

— Johannes Kuhn
fuente
55
@ nyuszika7h El idioma fue inventado antes de que se escribiera esta pregunta, por lo que es válido.
— Johannes Kuhn el
1
Sin embargo, sigue siendo una de las cosas para las que fue inventada. Parece como engañarme.
— nyuszika7h
77
@ nyuszika7h Y golfscript fue inventado para ganar en desafíos de código de golf. ¿Crees que eso también es trampa?
— Johannes Kuhn el
2
@Mego No es justo aplicar esos estándares aquí cuando fueron escritos un año después de esta respuesta.
— Pomo de la puerta
2
— Mego
2

C, 136 bytes

Nunca sentí que ninguna de mis soluciones fuera lo suficientemente buena como para publicar aquí, pero lo hice por diversión y pensé que sería mi droga de entrada al golf de código.

#define z(x) c>=x&&c<x+13
#define q(w) c>=w&&c<w+13
main(c){for(;(c=getchar())>=0;putchar(z('A')||z('a')?c+13:q('M')||q('m')?c-13:c));}
— Tormyst
fuente
44
Bienvenido a Programming Puzzles y Code Golf Stack Exchange. Gran primera respuesta. Y solo para que conste, todos nos sentimos así a veces, solo sabemos que cualquier cosa que crees es "lo suficientemente buena" en alguna parte.
— GamrCorps
2
Todo aquí en PPCG es solo por diversión (o puntos de Internet imaginarios): por favor, no sienta que el trabajo que ha hecho para elaborar una solución no es "lo suficientemente bueno"
— gato
Gracias por todo el apoyo. Creo que publicar algo era todo lo que necesitaba para poner mi cabeza en marcha. Voy a probar suerte en más de estos desafíos pronto.
— Tormyst
2

Javascript, 177 bytes

Esto supone que hay dos funciones, print y readLine:

f=String.fromCharCode;print(readLine().replace(/[a-z]/g,function(a){return f((a.charCodeAt(0)-84)%25+97);}).replace(/[A-Z]/g,function(a){return f((a.charCodeAt(0)-52)%25+65);}))
— jrtapsell
fuente
2

LispLisp (16,636)

Lo siento.

((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
  (lisp lisp))
 (((lisp (lisp (lisp (lisp lisp))))
   ((lisp (lisp (lisp lisp)))
    ((lisp (lisp (lisp (lisp lisp))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (((lisp (lisp (lisp (lisp lisp))))
          (((lisp (lisp (lisp (lisp lisp))))
            ((lisp (lisp (lisp lisp)))
             (lisp (lisp (lisp (lisp lisp))))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (lisp (lisp (lisp lisp)))))
            (((lisp (lisp (lisp (lisp lisp))))
              ((lisp (lisp (lisp lisp)))
               (lisp (lisp (lisp (lisp lisp))))))
             (((lisp (lisp (lisp (lisp lisp))))
               ((lisp (lisp (lisp lisp)))
                ((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))))
              (lisp (lisp (lisp lisp))))))))
         ((lisp (lisp (lisp lisp)))
          (lisp (lisp (lisp lisp)))))))
      (((lisp (lisp (lisp (lisp lisp))))
        ((lisp (lisp (lisp lisp)))
         (((lisp (lisp (lisp (lisp lisp))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (lisp (lisp (lisp lisp)))))))
            (((lisp (lisp (lisp (lisp lisp))))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 ((lisp (lisp (lisp lisp)))
                  ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
             ((lisp (lisp (lisp lisp)))
              (((((lisp (lisp (lisp (lisp lisp))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     (lisp (lisp (lisp (lisp lisp))))))
                   (lisp (lisp (lisp lisp)))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp (lisp lisp))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (lisp (lisp (lisp (lisp lisp))))))
                      (lisp (lisp (lisp lisp))))))
                   (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                    (lisp lisp)))
                  (((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (lisp lisp))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                     ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                 (lisp (lisp (lisp lisp)))))
               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 (((lisp (lisp (lisp (lisp lisp))))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp))
                     ((((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         ((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                           ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                       (lisp (lisp (lisp lisp))))))))
                  (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                         (lisp (lisp (lisp lisp))))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       (lisp lisp))))))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         (lisp (lisp (lisp (lisp lisp))))))
                       (lisp (lisp (lisp lisp)))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp))))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp (lisp lisp))))))
                           (lisp (lisp (lisp lisp)))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp))))
                             ((lisp (lisp (lisp lisp)))
                              (lisp (lisp (lisp (lisp lisp))))))
                            (lisp (lisp (lisp lisp)))))
                          (lisp lisp)))))
                      ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                        (lisp lisp))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       ((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                         ((lisp (lisp (lisp lisp)))
                          ((((lisp (lisp (lisp (lisp lisp))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                (lisp (lisp (lisp (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp (lisp lisp))))))
                                  (lisp (lisp (lisp lisp)))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  ((lisp (lisp (lisp lisp)))
                                   (lisp (lisp (lisp (lisp lisp))))))
                                 (lisp (lisp (lisp lisp)))))
                               (lisp lisp)))))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (lisp (lisp (lisp (lisp lisp))))))
                             (lisp (lisp (lisp lisp)))))))))))
                     (lisp (lisp (lisp lisp)))))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (((lisp (lisp (lisp (lisp lisp))))
                     ((lisp (lisp (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp)))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     ((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp lisp)))))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                              ((lisp (lisp (lisp lisp)))
                               ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
                          ((lisp (lisp (lisp lisp)))
                           (((((lisp (lisp (lisp (lisp lisp))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  (lisp (lisp (lisp (lisp lisp))))))
                                (lisp (lisp (lisp lisp)))))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp)))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      ((lisp (lisp (lisp lisp)))
                                       (lisp (lisp (lisp (lisp lisp))))))
                                     (lisp (lisp (lisp lisp)))))
                                   (lisp lisp)))))
                               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                                 (lisp lisp))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                ((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (lisp lisp))
                                  ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 ((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      ((lisp (lisp (lisp (lisp lisp))))
                                       (lisp lisp))))
                                    (lisp (lisp (lisp lisp))))))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp lisp)))))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp lisp)))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      (lisp lisp))
                                     (lisp lisp)))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp))))))))))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))))))))
                   (lisp (lisp (lisp lisp))))))))))))
          (lisp lisp))))
       (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
        ((lisp (lisp (lisp lisp)))
         (lisp (lisp (lisp lisp))))))))))
  (((lisp (lisp (lisp (lisp lisp))))
    (((lisp (lisp (lisp (lisp lisp))))
      ((lisp (lisp (lisp lisp)))
       (lisp (lisp (lisp (lisp lisp))))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (lisp (lisp (lisp lisp)))))
      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
       (lisp lisp)))))
   ((lisp (lisp (lisp lisp)))
    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
     ((lisp (lisp (lisp lisp)))
      ((lisp (lisp (lisp lisp))) (lisp lisp))))))))
— SYZYGY-DEV 333
fuente
¿Es este un lenguaje real con una implementación? Si es así, ¿puede vincularlo?
— Jo King
@JoKing Wikipedia TIO
— Benjamin Urquhart
@BenjaminUrquhart Sí, Lisp es un idioma. Lisplisp sin embargo, no he encontrado ninguna evidencia
— Jo King
— Benjamin Urquhart
1
Aquí hay un traductor para LazyK (en sí mismo, simplemente una implementación del cálculo de SKI Combinator). gist.github.com/SYZYGY-DEV333/d74ca36b9a4c504b25c0a2380203c98d
— SYZYGY-DEV 333
2

Código de máquina 8086, 27 bytes

Desmontado:

        STLOOP:
AC          LODSB               ; load byte from SI into AL, advance SI 
8B D0       MOV  DX, AX         ; save original char in DL 
0C 20       OR   AL, 020H       ; lowercase the char 
3C 61       CMP  AL, 'a'        ; is char less than 'a'? 
7C 0F       JL   STCHR          ; if so, do not rotate 
3C 7A       CMP  AL, 'z'        ; is char greater than 'z'? 
7F 0B       JG   STCHR          ; if so, do not rotate 
B6 0D       MOV  DH, 'n'-'a'    ; add or subtract 13 
3C 6E       CMP  AL, 'n'        ; is char less than 'n'? 
7C 02       JL   ADD13          ; if so, add positive 13 
F6 DE       NEG  DH             ; otherwise add -13 
        ADD13:
92          XCHG AX, DX         ; original char back to AL 
02 C4       ADD  AL, AH         ; add 13 or -13 to original char
        STCHR:
AA          STOSB               ; store converted byte into DI, advance DI 
E2 E5       LOOP STLOOP         ; continue loop through string

Cadena de entrada SI, longitud CX. Búfer de cadena de salida en DI.

Pruebe el resultado del programa DOS de IBM PC:

ingrese la descripción de la imagen aquí

Descargue el programa de prueba R13.COM (PC DOS).

— 640 KB
fuente
1

Haskell - 112 caracteres

r l=drop 13 l++take 13 l
t=['a'..'z']
s=['A'..'Z']
main=interact$map(\x->maybe x id$lookup x$zip(t++s)$r t++r s)
1

Tcl, 74 caracteres

package require [set c tcl::transform::rot];$c 13 stdin;fcopy stdin stdout
— Johannes Kuhn
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.