ROT-13 trasforma l'ingresso standard

34

La sfida: leggere un input di lunghezza arbitraria e produrre il ROT13 dell'input. Tutti i caratteri oltre a AZ devono essere copiati nell'output alla lettera e il caso deve essere conservato, se possibile.

Qualsiasi lingua in grado di leggere e scrivere stream standard è un gioco equo.

code-golf  cryptography 
— MiffTheFox
fonte
3
Il problema non dovrebbe essere un tag, quindi ho rimosso ROT13, solo un FYI
— Nick Berardi,
2
Non intendi A-Za-z (per contare sia maiuscole che minuscole)?
— Joey Adams,
5
@ Chris Jester-Young, appartiene a questa categoria su Wikipedia. Fa parte della crittografia, ma non è la più difficile. Comunque, non sto più seguendo questo sito. La comunità mi ha deluso. Scusate. GL HF.
— Nakilon,
17
Dire che xor non è crittografia è come dire a + b non è matematica .
— Nakilon,
3
I tag vengono utilizzati per classificare le domande e aiutare a cercare domande simili. Il tag di crittografia (dal greco kryptós, "nascosto, segreto"; e graphein, "scrittura") in particolare è per problemi di crittografia e decrittazione. Tutta la crittografia e la decrittografia, non solo quelle sicure per le applicazioni moderne.
— Angs,

Risposte:

25

Bash, 23 byte

Risposta canonica di 23 caratteri:

tr A-Za-z N-ZA-Mn-za-m
— Chris Jester-Young
fonte
1
Al momento non ho accesso a bash, ma penso che dovrebbe funzionare: tr A-za-m N-ZA-z(16 caratteri)
— Nabb,
2
@Nabb: Piacere di conoscerti, GolfScript-meister! MrGreen Penso che la tua soluzione qui romperebbe la clausola secondo cui "Tutti i caratteri oltre a AZ dovrebbero essere copiati all'output testualmente".
— Chris Jester-Young,
@ Chris: Sì, sembra che tu abbia ragione.
— Nabb,
@Nabb: No, a me sembra che abbia torto. O potresti mostrare un esempio?
— utente sconosciuto
2
@utente sconosciuto: digitare [\\]^_`l'input. Tornerà come NOPQRSpiuttosto che [\\]^_`, almeno nella versione trche ho. (Questi sono i sei personaggi in ASCII che si trovano tra Ze a. Ovviamente, tutti gli altri personaggi funzioneranno correttamente.)
— Chris Jester-Young,
20

Bash - 5 caratteri

rot13

 

— gnibbler
fonte
18
Finora due voti negativi (senza commenti), ma nessun voto negativo per la domanda. Presumo che significhi che va bene chiedere banali codegolf ma non dare la banale risposta. Codegolf più duro per favore!
— Gnibbler,
8
Quale versione bash? Non ho un rot13 incorporato. bash --version GNU bash, Version 4.0.33(1)-release (i486-pc-linux-gnu)
— utente sconosciuto
12
Lo avrei presentato come rot13 - 0 chars...;)
— stand
2
questo è coreutils amico mio, non Bash
— TheDoctor
3
erm ... no. my bash (Ubuntu 13.10) dice "comando non trovato, è possibile installare questo programma entro sudo apt-get install bsdgames"
17

Python 2, 34 byte

print raw_input().encode('rot13')
— Juan
fonte
1
-1 Penso che sia imbarazzante che tu stia utilizzando una libreria integrata.
— Glenn Nelson,
16
Li ho usati in tutti i codici golf a cui ho preso parte ... Anche se usare la lib standard di Python è barare, come sta usando tr no?
— Juan,
3
@Anon In ogni caso, è una risposta che semplicemente ignori .. Non è fuori bersaglio, non ci sono regole stabilite dall'OP né dalla comunità. Certo, forse la mia non è una soluzione pluripremiata, come quella che usa tr che prende a calci in culo. Ma non è uno scherzo, sto sfruttando il potere di Python per ridurre il conteggio, proprio come farebbe qualsiasi altro.
— Juan,
2
@Glenn: al contrario, non ho mai visto una cosa da code-golf che lo dica. Né codegolf.com, golf.shinh.org o SPOJ SHORTEN.
— hallvabo,
9
@Glenn, penso che le funzioni della libreria siano corrette. Sta alla domanda sul golf essere abbastanza interessante da non essere nella biblioteca di nessuno o da escludere in modo specifico.
— Gnibbler,
15

Befunge - 7x30 = 210 6x26 = 156 caratteri

Nuova versione di streaming che supporta sia lettere maiuscole che minuscole e dovrebbe supportare input illimitati.

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

La vecchia versione

Questo memorizza i valori all'interno del proprio codice sorgente. Mostra davvero quanto sia orribile provare a produrre valori memorizzati nello stesso ordine in cui li ricevi. Supporta solo caratteri minuscoli.

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

Non sono sicuro di quali siano le limitazioni, usando http://www.quirkster.com/iano/js/befunge.html come interprete sembra rompere con input di grandi dimensioni.

— Nemo157
fonte
È possibile rimuovere lo spazio bianco alla fine delle righe.
— Zacharý,
10

Rubino - 60 57 38 37 caratteri

Modifica: E appena realizzato le stringhe di Ruby hanno un trmetodo.

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

Test

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

dà:

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
fonte
Non hai bisogno di spazio dopo puts, e 'Az' è una scorciatoia per 'A-Za-z'
— Ventero
1
@Ventro: Grazie, dopo un po 'di test sembra in 'A-z'realtà 'A-Z[\]^_a-z' , damn ascii having characters between Z` e a.
— Nemo157,
1
Essenzialmente le stesse ma 35 caratteri: puts gets.tr'A-Za-z','N-ZA-Mn-za-m'.
— Michael Kohl,
@Michael: Tranne getsche restituisce solo la prima riga, usando $ <. Read read fino a EOF. La domanda non dice nulla sul fatto che l'input possa contenere nuove righe, quindi ho semplicemente sbagliato dal lato della cautela.
— Nemo157,
Abbastanza giusto, ma poiché le specifiche dell'esercizio menzionavano solo la "lunghezza arbitraria" ma non dicevano nulla sulle newline, preferirei sbagliare dalla brevità in codegolf ;-)
— Michael Kohl
10

vim, 5 sequenze di tasti

Supponendo la modalità normale e che il testo sia già scritto nel buffer:

ggg?G

Oppure, convenzioni di vimgolf in sospeso:

g?GZZ

Puoi anche invocarlo come comando terminale, in questo modo:

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

Immagino che quest'ultimo conterebbe come un "programma" di 8 caratteri ( norm g?G)

— daniero
fonte
norm g?Gè l'abbreviazione di normal g?G8 caratteri.
— Patrick Oscity,
Penso che puoi tranquillamente presumere di iniziare dalla linea 1, quindi il primo ggpuò essere lasciato fuori. Direi 3 battute quando il file è aperto.
— Patrick Oscity,
1
Se usiamo le convenzioni di vimgolf (inizi in una vim vanilla dopo aver appena aperto il file, ma devi salvare ed uscire) otteniamo anche 5 ( g?GZZ).
— FireFly,
7

C - 83 79 caratteri

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

Versione leggibile:

#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
fonte
1
Includete le intestazioni che includete nel conteggio?
— JPvdMerwe,
@JPvdMerwe: Non ho incluso alcun header nella versione golfata, né ne ho avuto bisogno.
— Joey Adams,
È possibile utilizzare l'operatore di coma prima di putchar per rimuovere un paio di parentesi graffe.
— Alexandru,
Potresti spiegare main (c, b)? È la prima volta che lo vedo.
— Alexandru,
2
@Alexandru molti compilatori C supportano main con qualsiasi parametro. Inoltre, lo standard C originale definisce che un argomento senza tipo è un int. In questo modo si arriva a dichiarare ints senza scrivere int.
— Juan,
7

Python (117 byte)

Ecco una versione di Python che evita il rot13()metodo.

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
fonte
raw_input restituisce una riga non tutto l'input.
— Alexandru,
è necessario import syse utilizzare sys.stdin.read().
— Alexandru,
@Alexandru: lo farà
— JPvdMerwe il
-2 byte se si elimina []per rendere l'elenco un generatore: tio.run/…
— connectyourcharger
7

tr///soluzione in Perl (39 caratteri), la caldaia può essere rimossa con -p:

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

Utilizzo -p(23 caratteri incluso l'interruttore extra):

perl -pe'y/a-zA-Z/n-za-mN-ZA-M/'
— Anon.
fonte
Aggiungi 1 carattere per la p, ma rimuovi la piastra della caldaia!
— JB,
7

R, 37 byte

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

example("chartr")esegue gli esempi per chartr, che include la rotfunzione, che è ROT13di default ....

— mnel
fonte
5

DC ( 111 108 per il DC stesso)

Ok, eccolo qui (per lo più) DC e un po 'di magia sed e od per farlo nel formato giusto per il codice. Se non conti la cosa di input ( echo -n MESSAGE |) sono 160 byte:

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'

Come punto di interesse, il programma DC stesso è lungo solo 108 byte , più corto della versione Python non di libreria. Conserva anche il caso e la punteggiatura e batte Javascript nella presentazione sopra! Se solo potessi analizzare meglio l'output di od, o meglio sostituirlo del tutto.

EDIT: Vale la pena notare che la domanda non indica una nuova riga finale 10Pche mi fa risparmiare altri tre byte.

EDIT 2: Non ci sono specifiche per il formato dell'input, quindi presumo che sia preso come è conveniente per il mio programma: P

— hiato
fonte
5

Befunge-93, 85 (griglia: 41x3 = 123)

Questa è una domanda antica, ma ho pensato di farla rivivere per pubblicare una risposta Befunge leggermente più bella.

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

Puoi provarlo qui . Inserisci un singolo carattere alla volta; termina inserendo un .carattere (puoi cambiarlo modificando il "."lato vicino alla destra della seconda riga). Funziona con lettere maiuscole e minuscole, nonché punteggiatura e senza limiti di input.

Non mi aspetto che questo ottenga un sacco di voti o altro, ma volevo solo dimostrare quanto sia davvero fantastico Befunge che puoi fare un po 'meglio dell'altra risposta.

Probabilmente potrei renderlo ancora più breve in Befunge-98.

— Kasran
fonte
Puoi aggiungere il mio frammento da qui per avere un interprete inline, se lo desideri. :)
— Ingo Bürk,
Ooh, non ho ancora studiato i frammenti. Dai un'occhiata, grazie!
— Kasran,
Questo non funziona se c'è uno spazio nell'input. Entra in un ciclo infinito nella sequenza >$! _perché hai due zeri nello stack in quel punto quando ti aspetti un valore diverso da zero.
— James Holderness,
4

PHP - 103 98 80 caratteri

(non usando str_rot13 ())

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

Delfi, 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
fonte
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 personaggio :)
— Wouter van Nifterick,
@Wouter van Nifterick: buon posto! Lo aggiornerò di conseguenza
— PatrickvL
4

Haskell, 100 personaggi

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

Java 251 caratteri

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
fonte
3

Python 3 (107)

Ok, prometto di smettere di rispondere a questa domanda ora, ma mi sono sentito obbligato a battere la risposta DC in Python. Questo probabilmente riflette male su di me come 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 caratteri

Bene, so che questo thread è morto da molto tempo, ma non potevo sopportare la (lunga) soluzione C che non si compila nemmeno su Clang (ma lo fa su GCC).

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

Probabilmente è quasi ancora comprimibile. Era certamente comprimibile. E non solo era comprimibile, ma era possibile renderlo ricorsivo.

— Fors
fonte
3

05AB1E , 13 12 byte

Salvataggio di un byte grazie a robbie0630

ADu)øJD2äRJ‡

Provalo online!

Spiegazione

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
fonte
Ho provato a --debugfarlo con questo , e sembra che ˜in questo caso sia una no-op e può essere tagliato.
— Robbie,
@ robbie0630: True. Non ho idea del perché l'ho avuto. Grazie :)
— 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))}))

Questa soluzione risolve il problema aggiungendo 13 al codice carattere se il carattere in questione si trova nella prima metà dell'alfabeto o sottraendo 13 se è nella seconda metà.

— Casey Chu
fonte
Puoi salvare 7 caratteri sostituendoli +(c.toLowerCase()<'n'?13:-13))con -13+26*/[a-m]/i.test(c).
— Jacob,
2

CHIQRSX9 + , 1

R

Devi solo usare lo strumento giusto per il problema.
CHIQRSX9 + è Turing completo e può leggere e scrivere da canali standard con C.

— Johannes Kuhn
fonte
5
@ nyuszika7h La lingua è stata inventata prima che questa domanda fosse scritta, quindi è valida.
— Johannes Kuhn,
1
È comunque una delle cose per cui è stata inventata. Sembra imbrogliarmi.
— nyuszika7h,
7
@ nyuszika7h E golfscript è stato inventato per vincere nelle sfide del code-golf. Pensi che anche questo sia barare?
— Johannes Kuhn,
2
@Mego Non è giusto applicare questi standard qui quando sono stati scritti un anno dopo questa risposta.
— Maniglia della porta
2
— Mego
2

C, 136 byte

Non ho mai pensato che nessuna delle mie soluzioni fosse abbastanza buona per essere pubblicata qui, ma l'ho fatta per divertimento e ho pensato che sarebbe stata la mia droga gateway nel code golf.

#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
fonte
4
Benvenuti in Puzzle di programmazione e scambio di code golf stack. Ottima prima risposta. E solo per la cronaca, a volte ci sentiamo tutti così, sappiamo solo che qualcosa che crei è "abbastanza buono" da qualche parte.
— GamrCorps,
2
Tutto qui su PPCG è solo per divertimento (o punti internet immaginari) - per favore, non sentire il lavoro che hai fatto per creare una soluzione non è "abbastanza buono"
— cat
Grazie per tutto il supporto. Penso che pubblicare qualcosa fosse tutto ciò di cui avevo bisogno per innestare la testa. Proverò presto la mia mano a molte di queste sfide.
— Tormyst,
2

Javascript, 177 byte

Ciò presuppone che ci siano due funzioni, print e 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
fonte
2

LispLisp (16.636)

Mi dispiace.

((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
  (lisp lisp))
 (((lisp (lisp (lisp (lisp lisp))))
   ((lisp (lisp (lisp lisp)))
    ((lisp (lisp (lisp (lisp lisp))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (((lisp (lisp (lisp (lisp lisp))))
          (((lisp (lisp (lisp (lisp lisp))))
            ((lisp (lisp (lisp lisp)))
             (lisp (lisp (lisp (lisp lisp))))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (lisp (lisp (lisp lisp)))))
            (((lisp (lisp (lisp (lisp lisp))))
              ((lisp (lisp (lisp lisp)))
               (lisp (lisp (lisp (lisp lisp))))))
             (((lisp (lisp (lisp (lisp lisp))))
               ((lisp (lisp (lisp lisp)))
                ((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))))
              (lisp (lisp (lisp lisp))))))))
         ((lisp (lisp (lisp lisp)))
          (lisp (lisp (lisp lisp)))))))
      (((lisp (lisp (lisp (lisp lisp))))
        ((lisp (lisp (lisp lisp)))
         (((lisp (lisp (lisp (lisp lisp))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (lisp (lisp (lisp lisp)))))))
            (((lisp (lisp (lisp (lisp lisp))))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 ((lisp (lisp (lisp lisp)))
                  ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
             ((lisp (lisp (lisp lisp)))
              (((((lisp (lisp (lisp (lisp lisp))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     (lisp (lisp (lisp (lisp lisp))))))
                   (lisp (lisp (lisp lisp)))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp (lisp lisp))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (lisp (lisp (lisp (lisp lisp))))))
                      (lisp (lisp (lisp lisp))))))
                   (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                    (lisp lisp)))
                  (((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (lisp lisp))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                     ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                 (lisp (lisp (lisp lisp)))))
               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 (((lisp (lisp (lisp (lisp lisp))))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp))
                     ((((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         ((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                           ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                       (lisp (lisp (lisp lisp))))))))
                  (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                         (lisp (lisp (lisp lisp))))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       (lisp lisp))))))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         (lisp (lisp (lisp (lisp lisp))))))
                       (lisp (lisp (lisp lisp)))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp))))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp (lisp lisp))))))
                           (lisp (lisp (lisp lisp)))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp))))
                             ((lisp (lisp (lisp lisp)))
                              (lisp (lisp (lisp (lisp lisp))))))
                            (lisp (lisp (lisp lisp)))))
                          (lisp lisp)))))
                      ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                        (lisp lisp))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       ((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                         ((lisp (lisp (lisp lisp)))
                          ((((lisp (lisp (lisp (lisp lisp))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                (lisp (lisp (lisp (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp (lisp lisp))))))
                                  (lisp (lisp (lisp lisp)))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  ((lisp (lisp (lisp lisp)))
                                   (lisp (lisp (lisp (lisp lisp))))))
                                 (lisp (lisp (lisp lisp)))))
                               (lisp lisp)))))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (lisp (lisp (lisp (lisp lisp))))))
                             (lisp (lisp (lisp lisp)))))))))))
                     (lisp (lisp (lisp lisp)))))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (((lisp (lisp (lisp (lisp lisp))))
                     ((lisp (lisp (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp)))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     ((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp lisp)))))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                              ((lisp (lisp (lisp lisp)))
                               ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
                          ((lisp (lisp (lisp lisp)))
                           (((((lisp (lisp (lisp (lisp lisp))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  (lisp (lisp (lisp (lisp lisp))))))
                                (lisp (lisp (lisp lisp)))))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp)))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      ((lisp (lisp (lisp lisp)))
                                       (lisp (lisp (lisp (lisp lisp))))))
                                     (lisp (lisp (lisp lisp)))))
                                   (lisp lisp)))))
                               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                                 (lisp lisp))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                ((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (lisp lisp))
                                  ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 ((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      ((lisp (lisp (lisp (lisp lisp))))
                                       (lisp lisp))))
                                    (lisp (lisp (lisp lisp))))))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp lisp)))))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp lisp)))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      (lisp lisp))
                                     (lisp lisp)))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp))))))))))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))))))))
                   (lisp (lisp (lisp lisp))))))))))))
          (lisp lisp))))
       (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
        ((lisp (lisp (lisp lisp)))
         (lisp (lisp (lisp lisp))))))))))
  (((lisp (lisp (lisp (lisp lisp))))
    (((lisp (lisp (lisp (lisp lisp))))
      ((lisp (lisp (lisp lisp)))
       (lisp (lisp (lisp (lisp lisp))))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (lisp (lisp (lisp lisp)))))
      (((lisp (lisp (lisp (lisp lisp)))) (lisp 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
fonte
È una lingua reale con un'implementazione? In tal caso, puoi collegarti ad esso?
— Jo King,
@JoKing Wikipedia TIO
— Benjamin Urquhart
@BenjaminUrquhart Sì, Lisp è una lingua. Lisplisp, tuttavia, non ho trovato alcuna prova
— Jo King,
@JoKing oh capisco. Forse si riferiva a questo?
— Benjamin Urquhart,
1
Ecco un traduttore per LazyK (è semplicemente un'implementazione del calcolo del combinatore SKI). gist.github.com/SYZYGY-DEV333/d74ca36b9a4c504b25c0a2380203c98d
— SYZYGY-DEV 333
2

8086 Codice macchina, 27 byte

smontato:

        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

Inserire la stringa in SI, lunghezza in CX. Buffer di stringa di output a DI.

Test dell'output del programma IBM PC DOS:

inserisci qui la descrizione dell'immagine

Scarica il programma di test R13.COM (PC DOS).

— 640KB
fonte
1

Haskell - 112 caratteri

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 caratteri

package require [set c tcl::transform::rot];$c 13 stdin;fcopy stdin stdout
— Johannes Kuhn
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.