Entrée standard de transformation ROT-13

34

Le défi: lire une entrée de longueur arbitraire et produire le ROT13 de l’entrée. Tous les caractères autres que AZ doivent être copiés intégralement dans la sortie et la casse doit être préservée si possible.

Toute langue capable de lire et d’écrire des flux standard est un jeu équitable.

code-golf  cryptography 
— MiffTheFox
source
3
Le problème ne devrait pas être une étiquette, alors j'ai enlevé ROT13, juste un FYI
— Nick Berardi le
2
Ne voulez-vous pas dire A-Za-z (compter les majuscules et les minuscules)?
— Joey Adams
5
@ Chris Jester-Young, il appartient à cette catégorie sur wikipedia. Cela fait partie de la cryptographie, mais pas la plus difficile. En tout cas, je ne suis plus sur ce site. La communauté m'a déçu. Désolé. GL HF.
— Nakilon
17
Dire que xor n’est pas un cryptage revient à dire que a + b n’est pas un calcul .
— Nakilon
3
Les balises sont utilisées pour classer les questions et aider à rechercher des questions similaires. La balise de cryptographie (du grec kryptós, "caché, secret"; et graphein, "écriture") concerne en particulier les problèmes de cryptage et de décryptage. Tous les cryptages et décryptages, pas seulement ceux qui sont sécurisés pour les applications modernes.
— Angs

Réponses:

25

Bash, 23 octets

Réponse canonique à 23 caractères:

tr A-Za-z N-ZA-Mn-za-m
— Chris Jester-Young
source
1
Je n'ai pas accès à bash pour le moment, mais je pense que cela devrait fonctionner: tr A-za-m N-ZA-z(16 caractères)
— Nabb
2
@Nabb: Ravi de vous voir, GolfScript-meister! : -DI pense que votre solution contreviendrait à la stipulation suivante: "Tous les caractères autres que AZ doivent être copiés intégralement dans la sortie".
— Chris Jester-Young le
@ Chris: Oui, on dirait que tu as raison.
— Nabb
@Nabb: Non, il me semble qu'il a tort. Ou pouvez-vous montrer un exemple?
— utilisateur inconnu
2
@utilisateur inconnu: Tapez [\\]^_`dans l'entrée. Il reviendra comme NOPQRSplutôt que [\\]^_`, du moins dans la version de trmoi. (Ce sont les six caractères ASCII qui se situent entre Zet a. De toute évidence, tous les autres caractères fonctionneront correctement.)
— Chris Jester-Young Le
20

Bash - 5 caractères

rot13

 

— gnibbler
source
18
Deux votes négatifs jusqu'à présent (sans commentaires), mais aucun vote négatif pour la question. Je suppose que cela signifie que vous pouvez poser des questions sur des codesgolf triviaux mais pas sur une réponse triviale. Des codes plus difficiles s'il vous plaît!
— Gnibbler
8
Quelle version bash? Je n'ai pas de rot13 intégré. bash --version GNU bash, Version 4.0.33(1)-release (i486-pc-linux-gnu)
— utilisateur inconnu
12
J'aurais soumis ceci comme rot13 - 0 chars...;)
— stand par
2
'tis coreutils mon ami, pas Bash
— TheDoctor
3
euh ... non. mon bash (Ubuntu 13.10) dit "commande introuvable, vous pouvez installer ce programme par sudo apt-get install bsdgames"
17

Python 2, 34 octets

print raw_input().encode('rot13')
— Juan
source
1
-1 Je pense que c'est tricher que vous utilisiez une bibliothèque intégrée.
— Glenn Nelson
16
Je les ai utilisés dans tous les codes de golf auxquels j'ai participé ... De plus, si utiliser la bibliothèque standard de Python est une tricherie, comment utiliser tr n'est-il pas?
— Juan le
3
@Anon En tout cas, c'est une réponse qu'il faut ignorer. Ce n'est pas hors de propos, il n'y a pas de règles définies par l'OP ni par la communauté. Bien sûr, peut-être que la mienne n’est pas une solution primée, comme celle qui utilise tr qui donne un coup de pied au cul. Mais ce n'est pas une blague, je profite de la puissance de Python pour réduire le nombre, comme n'importe quel autre.
— Juan le
2
@ Glenn: au contraire, je n'ai jamais vu un code-golf qui le dit. Ni codegolf.com, golf.shinh.org ni SPOJ SHORTEN.
— hallvabo
9
@ Glenn, je pense que les fonctions de la bibliothèque sont un jeu équitable. Il faut que la question du golf soit suffisamment intéressante pour ne pas figurer dans la bibliothèque de qui que ce soit ou pour être exclue spécifiquement.
— Gnibbler
15

Befunge - 7x30 = 210 6x26 = 156 caractères

Nouvelle version en streaming qui prend en charge les majuscules et les minuscules et devrait permettre une entrée illimitée.

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

L'ancienne version

Cela stocke les valeurs dans son propre code source. Montre vraiment à quel point il est horrible d'essayer de générer des valeurs stockées dans le même ordre que vous les avez reçues. Ne supporte que les caractères minuscules.

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

Je ne sais pas exactement quelles sont les limitations, en utilisant http://www.quirkster.com/iano/js/befunge.html en tant qu'interpréteur, il semble rompre avec les entrées volumineuses.

— Nemo157
source
Vous pouvez supprimer les espaces en fin de ligne.
— Zacharý
10

Ruby - 60 57 38 37 caractères

Edit: Et je viens de me rendre compte que les chaînes Ruby ont une trméthode.

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

Tester

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

Donne:

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
source
Vous n'avez pas besoin d'espace après puts, et 'Az' est un raccourci pour 'A-Za-z'
— Ventero
1
@Ventro: Merci, après un peu de test, il semble que 'A-z'c'est en fait 'A-Z[\]^_un 'Z' , damn ascii having characters between et a.
— Nemo157
1
Essentiellement les mêmes , mais 35 caractères: puts gets.tr'A-Za-z','N-ZA-Mn-za-m'.
— Michael Kohl
@Michael: Except getsne renvoie que la première ligne, utilisez $ <. Read lit jusqu'à EOF. La question ne dit pas si l'entrée peut contenir de nouvelles lignes, alors je me suis simplement trompé de prudence.
— Nemo157
C'est assez vrai, mais puisque les spécifications de l'exercice ne mentionnaient que la "longueur arbitraire" mais ne disaient rien des nouvelles lignes, je préférerais plutôt pécher par excès de brièveté dans codegolf ;-)
— Michael Kohl
10

vim, 5 frappes

En supposant que le mode soit normal et que le texte est déjà écrit dans le tampon:

ggg?G

Ou, suivant les conventions de vimgolf:

g?GZZ

Vous pouvez également l'invoquer en tant que commande de terminal, à peu près comme ceci:

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

Je suppose que ce dernier compterait comme un "programme" de 8 caractères ( norm g?G)

— Daniero
source
norm g?Gest l'abréviation de normal g?Gqui fait 8 caractères.
— Patrick Oscity
Je pense que vous pouvez sans risque supposer de commencer par la ligne 1, de sorte que la première ggpeut être laissée. Je dirais 3 frappes lorsque le fichier est ouvert.
— Patrick Oscity
1
Si nous utilisons les conventions de vimgolf (vous commencez avec une vanille qui vient d'ouvrir le fichier, mais vous devez enregistrer et quitter), nous obtenons également 5 ( g?GZZ).
— FireFly
7

C - 83 79 caractères

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

Version lisible:

#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
source
1
Incluez-vous les en-têtes que vous incluez dans votre compte?
— JPvdMerwe
@JPvdMerwe: Je n'ai inclus aucun en-tête dans la version avec golf, et je n'ai pas eu besoin de le faire.
— Joey Adams
Vous pouvez utiliser l'opérateur coma avant putchar pour retirer une paire d'accolades.
— Alexandru
Pourriez-vous expliquer principal (c, b)? C'est la première fois que je vois ça.
— Alexandru
2
@Alexandru la plupart des compilateurs C supportent main avec n'importe quel paramètre. En outre, la norme C d'origine définit qu'un argument sans type est un entier. Ainsi, vous obtenez de déclarer ints sans écrire réellement int.
— Juan le
7

Python (117 octets)

Voici une version en Python qui évite la rot13()méthode.

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
source
raw_input renvoie une ligne, mais pas toutes les entrées.
— Alexandru
vous devez import syset utiliser sys.stdin.read().
— Alexandru
@Alexandru: va faire
— JPvdMerwe
-2 octets si vous supprimez le []pour rendre la liste compilant
— connectyourcharger
7

tr///solution en Perl (39 caractères), le passe-partout peut être enlevé avec -p:

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

Utilisation -p(23 caractères, y compris le commutateur supplémentaire):

perl -pe'y/a-zA-Z/n-za-mN-ZA-M/'
— Anon
source
Ajoutez 1 caractère pour le p, mais veuillez retirer le passe-partout!
— JB
7

R, 37 octets

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

example("chartr")exécute les exemples pour chartr, qui inclut la rotfonction, qui est ROT13par défaut ....

— couloir
source
5

DC ( 111 108 pour le dc lui-même)

Ok, ici, il est en (la plupart du temps) DC et un peu de magie sed et od pour le mettre dans le bon format pour le code. Si vous ne comptez pas la chose en entrée ( echo -n MESSAGE |), c'est 160 octets:

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'

Il est intéressant de noter que le programme dc lui-même ne fait que 108 octets de long, plus court que la version python hors bibliothèque. Il préserve même la casse et la ponctuation, et bat Javascript dans la soumission ci-dessus! Si seulement je pouvais mieux analyser le résultat de od, ou encore mieux le remplacer complètement.

EDIT: Il convient de noter que la question n'indique pas une nouvelle ligne de fuite 10P ce qui me permet d’économiser trois octets supplémentaires.

EDIT 2: Il n’existe aucune spécification sur le format de l’entrée, donc je suppose qu’il est pris comme il convient pour mon programme: P

— Hiato
source
5

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

C'est une question ancienne, mais je pensais la réactiver pour poster une réponse légèrement plus agréable en Befunge.

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

Vous pouvez le tester ici . Entrez un seul caractère à la fois; il se termine en entrant dans un. caractère (vous pouvez le modifier en modifiant le "."côté droit de la deuxième ligne). Fonctionne avec les majuscules et les minuscules, ainsi que la ponctuation et sans limite de saisie.

Je ne m'attends pas à ce que cela obtienne une tonne de votes positifs, mais je voulais simplement montrer à quel point Befunge est génial. que vous pouvez faire un peu mieux que l'autre réponse.

Je pourrais probablement le rendre encore plus court dans Befunge-98.

— Kasran
source
Vous pouvez ajouter mon extrait d'ici pour avoir un interprète intégré, si vous le souhaitez. :)
— Ingo Bürk
Ooh, je n'ai pas encore vraiment étudié les extraits. Je vais jeter un coup d'oeil, merci!
— Kasran
Cela ne fonctionne pas s'il y a un espace dans l'entrée. Il se met dans une boucle infinie dans la séquence >$! _car vous avez deux zéros sur la pile à ce point lorsque vous attendez une valeur non nulle.
— James Holderness le
4

PHP - 103 98 80 caractères

(n'utilise pas str_rot13 ())

<?=preg_replace('#[a-zA-Z]#e','chr(($x=ord("\0"))-$x%32+1+($x%32+12)%26)',`cat`);
— Arnaud Le Blanc
source
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
source
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.sauve un personnage :)
— Wouter van Nifterick
@Wouter van Nifterick: bon spot! Je vais le mettre à jour en conséquence
— PatrickvL
4

Haskell, 100 caractères

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

Java 251 caractères

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

Python 3 (107)

Ok, je promets de ne plus répondre à cette question maintenant, mais je me suis senti obligé de battre la réponse de DC en Python. Cela reflète probablement mal sur moi en tant que personne :).

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 caractères

Bon, je sais que ce fil est mort depuis longtemps, mais je ne pouvais pas supporter la (longue) solution C qui ne compile même pas sur Clang (mais le fait sur GCC).

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

Il est probablement presque toujours compressible. C'était certainement compressible. Et non seulement c'était compressible, il était possible de le rendre récursif.

— Fors
source
3

05AB1E , 13 12 octets

A enregistré un octet grâce à robbie0630

ADu)øJD2äRJ‡

Essayez-le en ligne!

Explication

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
source
J'ai parcouru cela avec --debug, et il semble que ce ˜soit un non-op dans ce cas et peut être coupé.
— robbie
@ robbie0630: vrai. Je ne sais pas pourquoi j'avais ça. Merci :)
— 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))}))

Cette solution résout le problème en ajoutant 13 au code de caractère si le caractère en question est dans la première moitié de l'alphabet, ou en soustrayant 13 si c'est dans la seconde moitié.

— Casey Chu
source
Vous pouvez enregistrer 7 caractères en remplaçant +(c.toLowerCase()<'n'?13:-13))par -13+26*/[a-m]/i.test(c).
— Jacob
2

CHIQRSX9 + , 1

R

Vous devez juste utiliser le bon outil pour le problème.
CHIQRSX9 + est complet et peut lire et écrire à partir de canaux standard avec C.

— Johannes Kuhn
source
5
@ nyuszika7h Le langage a été inventé avant l'écriture de cette question, il est donc valide.
— Johannes Kuhn
1
C'est quand même l'une des choses pour lesquelles il a été inventé. On dirait que je triche.
— Nyuszika7h
7
@ nyuszika7h Et golfscript a été inventé pour gagner des défis en code-golf. Pensez-vous que c'est tricher aussi?
— Johannes Kuhn
2
@ Mego Il n'est pas juste d'appliquer ces normes ici, lorsqu'elles ont été écrites un an après cette réponse.
— Poignée de porte
2
— Mego
2

C, 136 octets

Je ne me suis jamais senti qu'une de mes solutions était assez bonne pour être postée ici, mais je l'ai faite pour le plaisir, et j'ai pensé que ce serait ma drogue d'introduction au 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
source
4
Bienvenue dans Programmation Puzzles et Code Golf Stack Exchange. Super première réponse. Et juste pour le compte rendu, nous pensons tous de cette façon parfois, sachez simplement que tout ce que vous créez est "assez bon" quelque part.
— GamrCorps
2
Tout ici sur PPCG est juste pour le plaisir (ou des points Internet imaginaires) - s'il vous plaît, ne pensez pas que le travail que vous avez accompli pour élaborer une solution ne soit pas "assez bon"
— cat
Merci pour tout le soutien. Je pense que poster quelque chose était tout ce dont j'avais besoin pour me mettre en tête. Je vais bientôt essayer plus de ces défis.
— Tormyst
2

Javascript, 177 octets

Cela suppose qu'il existe deux fonctions, print et 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
source
2

LispLisp (16 636)

Je suis désolé.

((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
  (lisp lisp))
 (((lisp (lisp (lisp (lisp lisp))))
   ((lisp (lisp (lisp lisp)))
    ((lisp (lisp (lisp (lisp lisp))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (((lisp (lisp (lisp (lisp lisp))))
          (((lisp (lisp (lisp (lisp lisp))))
            ((lisp (lisp (lisp lisp)))
             (lisp (lisp (lisp (lisp lisp))))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (lisp (lisp (lisp lisp)))))
            (((lisp (lisp (lisp (lisp lisp))))
              ((lisp (lisp (lisp lisp)))
               (lisp (lisp (lisp (lisp lisp))))))
             (((lisp (lisp (lisp (lisp lisp))))
               ((lisp (lisp (lisp lisp)))
                ((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))))
              (lisp (lisp (lisp lisp))))))))
         ((lisp (lisp (lisp lisp)))
          (lisp (lisp (lisp lisp)))))))
      (((lisp (lisp (lisp (lisp lisp))))
        ((lisp (lisp (lisp lisp)))
         (((lisp (lisp (lisp (lisp lisp))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (lisp (lisp (lisp lisp)))))))
            (((lisp (lisp (lisp (lisp lisp))))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 ((lisp (lisp (lisp lisp)))
                  ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
             ((lisp (lisp (lisp lisp)))
              (((((lisp (lisp (lisp (lisp lisp))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     (lisp (lisp (lisp (lisp lisp))))))
                   (lisp (lisp (lisp lisp)))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp (lisp lisp))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (lisp (lisp (lisp (lisp lisp))))))
                      (lisp (lisp (lisp lisp))))))
                   (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                    (lisp lisp)))
                  (((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (lisp lisp))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                     ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                 (lisp (lisp (lisp lisp)))))
               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 (((lisp (lisp (lisp (lisp lisp))))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp))
                     ((((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         ((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                           ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                       (lisp (lisp (lisp lisp))))))))
                  (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                         (lisp (lisp (lisp lisp))))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       (lisp lisp))))))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         (lisp (lisp (lisp (lisp lisp))))))
                       (lisp (lisp (lisp lisp)))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp))))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp (lisp lisp))))))
                           (lisp (lisp (lisp lisp)))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp))))
                             ((lisp (lisp (lisp lisp)))
                              (lisp (lisp (lisp (lisp lisp))))))
                            (lisp (lisp (lisp lisp)))))
                          (lisp lisp)))))
                      ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                        (lisp lisp))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       ((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                         ((lisp (lisp (lisp lisp)))
                          ((((lisp (lisp (lisp (lisp lisp))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                (lisp (lisp (lisp (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp (lisp lisp))))))
                                  (lisp (lisp (lisp lisp)))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  ((lisp (lisp (lisp lisp)))
                                   (lisp (lisp (lisp (lisp lisp))))))
                                 (lisp (lisp (lisp lisp)))))
                               (lisp lisp)))))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (lisp (lisp (lisp (lisp lisp))))))
                             (lisp (lisp (lisp lisp)))))))))))
                     (lisp (lisp (lisp lisp)))))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (((lisp (lisp (lisp (lisp lisp))))
                     ((lisp (lisp (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp)))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     ((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp lisp)))))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                              ((lisp (lisp (lisp lisp)))
                               ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
                          ((lisp (lisp (lisp lisp)))
                           (((((lisp (lisp (lisp (lisp lisp))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  (lisp (lisp (lisp (lisp lisp))))))
                                (lisp (lisp (lisp lisp)))))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp)))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      ((lisp (lisp (lisp lisp)))
                                       (lisp (lisp (lisp (lisp lisp))))))
                                     (lisp (lisp (lisp lisp)))))
                                   (lisp lisp)))))
                               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                                 (lisp lisp))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                ((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (lisp lisp))
                                  ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 ((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      ((lisp (lisp (lisp (lisp lisp))))
                                       (lisp lisp))))
                                    (lisp (lisp (lisp lisp))))))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp lisp)))))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp lisp)))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      (lisp lisp))
                                     (lisp lisp)))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp))))))))))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))))))))
                   (lisp (lisp (lisp lisp))))))))))))
          (lisp lisp))))
       (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
        ((lisp (lisp (lisp lisp)))
         (lisp (lisp (lisp lisp))))))))))
  (((lisp (lisp (lisp (lisp lisp))))
    (((lisp (lisp (lisp (lisp lisp))))
      ((lisp (lisp (lisp lisp)))
       (lisp (lisp (lisp (lisp lisp))))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (lisp (lisp (lisp lisp)))))
      (((lisp (lisp (lisp (lisp lisp)))) (lisp 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
source
Est-ce un langage réel avec une implémentation? Si oui, pouvez-vous s'il vous plaît créer un lien?
— Jo King le
@JoKing Wikipedia TIO
— Benjamin Urquhart
@BenjaminUrquhart Oui, Lisp est un langage. Lisplisp cependant, je n'ai trouvé aucune preuve existe
— Jo King
— Benjamin Urquhart
1
Voici un traducteur pour LazyK (une simple implémentation du calcul SKI Combinator). gist.github.com/SYZYGY-DEV333/d74ca36b9a4c504b25c0a2380203c98d
— SYZYGY-DEV 333 le
2

8086 Code machine, 27 octets

Non assemblé:

        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

Chaîne d'entrée dans SI, longueur dans CX. Sortie du tampon de chaîne à DI.

Testez la sortie du programme IBM PC DOS:

entrez la description de l'image ici

Téléchargez le programme de test R13.COM (PC DOS).

— 640 Ko
source
1

Haskell - 112 caractères

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 caractères

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