ROT-13-Transformations-Standardeingang

34

Die Herausforderung: Einen Eingang beliebiger Länge auslesen und den ROT13 des Eingangs erzeugen . Alle Zeichen außer AZ sollten wörtlich in die Ausgabe kopiert werden, und Groß- / Kleinschreibung sollte nach Möglichkeit beibehalten werden.

Jede Sprache, die Standard-Streams lesen und schreiben kann, ist ein faires Spiel.

code-golf  cryptography 
— MiffTheFox
quelle
3
Das Problem sollte kein Tag sein, also habe ich ROT13 entfernt, nur ein FYI
— Nick Berardi
2
Meinen Sie nicht A-Za-z (um sowohl Groß- als auch Kleinbuchstaben zu zählen)?
— Joey Adams
5
@ Chris Jester-Young, es gehört zu dieser Kategorie bei Wikipedia. Es ist ein Teil der Kryptographie, nur nicht der schwierigste. Jedenfalls verfolge ich diese Seite nicht mehr. Community hat mich enttäuscht. Es tut uns leid. VIEL GLÜCK UND VIEL SPASS.
— Nakilon
17
Wenn Sie sagen, dass xoder keine Verschlüsselung ist, dann ist das wie wenn Sie sagen, dass a + b keine Mathematik ist .
— Nakilon
3
Tags werden verwendet, um Fragen zu kategorisieren und ähnliche Fragen zu durchsuchen. Das Kryptographie- Tag (aus dem Griechischen kryptós, "versteckt, geheim", und graphein, "Schreiben") ist insbesondere für Verschlüsselungs- und Entschlüsselungsprobleme gedacht. Alle Ver- und Entschlüsselungen, nicht nur die, die für moderne Anwendungen sicher sind.
— Angs

Antworten:

25

Bash, 23 Bytes

Kanonische Antwort mit 23 Zeichen:

tr A-Za-z N-ZA-Mn-za-m
— Chris Jester-Young
quelle
1
Ich habe im Moment keinen Zugang zu Bash, aber ich denke, das sollte funktionieren: tr A-za-m N-ZA-z(16 Zeichen)
— Nabb
2
@Nabb: Schön dich zu sehen, GolfScript-meister! : -DI Ich denke, Ihre Lösung hier würde die Bedingung brechen, dass "alle Zeichen außer AZ wörtlich in die Ausgabe kopiert werden sollten".
— Chris Jester-Young
@ Chris: Ja, sieht so aus, als hättest du recht.
— Nabb
@Nabb: Nein, für mich sieht es so aus, als ob er sich irrt. Oder können Sie ein Beispiel zeigen?
— Benutzer unbekannt
2
@user unbekannt: Geben Sie [\\]^_`die Eingabe ein. Es wird NOPQRSeher als zurückkommen [\\]^_`, zumindest in der Version, die trich habe. (Dies sind die sechs Zeichen in ASCII, die zwischen Zund liegen a. Offensichtlich werden alle anderen Zeichen korrekt funktionieren.)
— Chris Jester-Young
20

Bash - 5 Zeichen

rot13

 

— Knabberzeug
quelle
18
Bisher zwei Downvotes (ohne Kommentare), aber keine Downvotes für die Frage. Ich gehe davon aus, dass es in Ordnung ist, triviale Codegolfspieler zu fragen, aber keine triviale Antwort zu geben. Härtere Codegolfs bitte!
— Gnibbler
8
Welche Bash-Version? Ich habe kein eingebautes rot13. bash --version GNU bash, Version 4.0.33(1)-release (i486-pc-linux-gnu)
— Benutzer unbekannt
12
Ich hätte dies eingereicht als rot13 - 0 chars...;)
— Stand
2
'tis coreutils mein Freund, nicht Bash
— TheDoctor
3
ähm ... nein. Mein Bash (Ubuntu 13.10) sagt "Befehl nicht gefunden, Sie können dieses Programm installieren von sudo apt-get install bsdgames"
17

Python 2, 34 Bytes

print raw_input().encode('rot13')
— Juan
quelle
1
-1 Ich denke, es ist Betrug, dass Sie eine eingebaute Bibliothek verwenden.
— Glenn Nelson
16
Ich habe sie in jedem Code-Golf verwendet, an dem ich teilgenommen habe.
— Juan
3
@Anon Auf jeden Fall handelt es sich um eine Antwort, die Sie einfach ignorieren. Sie ist nicht falsch, es gibt weder vom OP noch von der Community festgelegte Regeln. Sicher, vielleicht ist meins keine preisgekrönte Lösung, wie die mit Tr, die Arsch tritt. Aber es ist kein Scherz, ich nutze die Kraft von Python, um die Anzahl zu verringern, genau wie es jeder andere tun würde.
— Juan
2
@Glenn: Im Gegenteil, ich habe noch nie eine Code-Golf-Sache gesehen, die das so aussagt. Weder codegolf.com, golf.shinh.org noch SPOJ SHORTEN.
— Hallvabo
9
@Glenn, ich denke Bibliotheksfunktionen sind faires Spiel. Es liegt an der Frage des Golfsports, interessant genug zu sein, um nicht in der Bibliothek von irgendjemandem zu sein oder ausdrücklich auszuschließen.
— Gnibbler
15

Befunge - 7x30 = 210 6x26 = 156 Zeichen

Neue Streaming-Version, die sowohl Groß- als auch Kleinbuchstaben unterstützt und unbegrenzte Eingaben unterstützen sollte.

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

Die alte Version

Dadurch werden die Werte in einem eigenen Quellcode gespeichert. Zeigt wirklich, wie schrecklich es ist, gespeicherte Werte in derselben Reihenfolge auszugeben, in der Sie sie erhalten. Unterstützt nur Kleinbuchstaben.

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

Ich bin mir nicht sicher, welche Einschränkungen dies hat, wenn http://www.quirkster.com/iano/js/befunge.html als Interpreter verwendet wird, der bei großen Eingaben offenbar nicht funktioniert.

— Nemo157
quelle
Sie können das Leerzeichen am Zeilenende entfernen.
— Zacharý
10

Ruby - 60 57 38 37 Zeichen

Edit: Und gerade realisiert Ruby Strings haben eine trMethode.

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

Prüfung

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

Gibt:

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
quelle
Sie brauchen kein Leerzeichen mehr puts, und 'Az' ist eine Abkürzung für 'A-Za-z'
— Ventero
1
@Ventro: Danke, nach einigem Testen scheint 'A-z'es tatsächlich 'A-Z[\]^_a-z " , damn ascii having characters between Z" und zu sein a.
— Nemo157,
1
Im Wesentlichen die gleichen , aber 35 Zeichen: puts gets.tr'A-Za-z','N-ZA-Mn-za-m'.
— Michael Kohl
@Michael: Außer es wird getsnur die erste Zeile zurückgegeben, wobei $ <. Read bis EOF gelesen wird. Die Frage sagt nichts darüber aus, ob die Eingabe neue Zeilen enthalten kann, so dass ich mich nur zur Vorsicht geirrt habe.
— Nemo157
Fair genug, aber da die Übungsspezifikation nur "willkürliche Länge" erwähnte, aber nichts über Zeilenumbrüche aussagte, würde ich mich eher auf der Seite der Kürze im Codegolf irren ;-)
— Michael Kohl
10

Vim, 5 Tastenanschläge

Angenommen, der normale Modus und der Text sind bereits im Puffer geschrieben:

ggg?G

Oder fälschlicherweise Vimgolfs Konventionen:

g?GZZ

Sie können es auch als Terminalbefehl wie folgt aufrufen:

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

Ich denke, das letztere würde als "Programm" von 8 Zeichen zählen ( norm g?G)

— daniero
quelle
norm g?Gist eine Abkürzung für normal g?G8 Zeichen.
— Patrick Oscity
Ich denke, Sie können davon ausgehen, dass Sie in Zeile 1 beginnen, sodass die erste Zeile weggelassen werden ggkann. Ich würde sagen, 3 Tastenanschläge, wenn die Datei geöffnet ist.
— Patrick Oscity
1
Wenn wir Vimgolfs Konventionen verwenden (Sie starten in einem Vanille-Vim, der die Datei gerade geöffnet hat, aber speichern und beenden muss), erhalten wir auch 5 ( g?GZZ).
— FireFly
7

C - 83 79 Zeichen

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

Lesbare Version:

#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
quelle
1
Beziehen Sie die Überschriften ein, die Sie in Ihre Zählung einbeziehen?
— JPvdMerwe
@JPvdMerwe: Ich habe keine Überschriften in die Golfversion aufgenommen und musste auch nicht.
— Joey Adams
Sie können den Koma-Operator vor Putchar verwenden, um ein Paar Klammern zu entfernen.
— Alexandru
Können Sie main (c, b) erklären? Es ist das erste Mal, dass ich das sehe.
— Alexandru
2
@Alexandru Die meisten C-Compiler unterstützen main mit beliebigen Parametern. Der ursprüngliche C-Standard definiert außerdem, dass ein Argument ohne Typ ein Int ist. So können Sie ints deklarieren, ohne int zu schreiben.
— Juan
7

Python (117 Bytes)

Hier ist eine Python-Version, die die rot13()-Methode vermeidet .

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
quelle
raw_input gibt eine Zeile zurück, nicht alle Eingaben.
— Alexandru
Sie müssen import sysund verwenden sys.stdin.read().
— Alexandru
@ Alexandru: wird tun
— JPvdMerwe
-2 Bytes, wenn Sie das entfernen[] , um die Liste zu einem Generator zu machen: tio.run/…
— connectyourcharger
7

tr///Lösung in Perl (39 Zeichen), Boilerplate kann entfernt werden mit -p:

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

Verwenden von -p(23 Zeichen einschließlich des zusätzlichen Schalters):

perl -pe'y/a-zA-Z/n-za-mN-ZA-M/'
— Anon.
quelle
Fügen Sie 1 Zeichen für das P hinzu, aber entfernen Sie bitte das Boilerplate!
— JB
7

R, 37 Bytes

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

example("chartr")führt die Beispiele für aus chartr, einschließlich der rotFunktion, die ROT13standardmäßig ... ist.

— mnel
quelle
5

Gleichstrom ( 111 108 für den Gleichstrom selbst)

Ok, hier ist es (meistens) in dc und etwas sed und od Magie, um es in das richtige Format für den Code zu bringen. Wenn Sie die Eingabe thing ( echo -n MESSAGE |) nicht zählen, sind es 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'

Aus Gründen des Interesses ist das DC-Programm selbst nur 108 Byte lang und damit kürzer als die Python-Version ohne Bibliothek. Es bewahrt auch Fall und Zeichensetzung und schlägt Javascript in der obigen Vorlage! Wenn ich nur die Ausgabe von od besser analysieren oder besser ersetzen könnte.

EDIT: Es ist erwähnenswert, dass die Frage keine nachgestellte neue Zeile anzeigt, 10Pdie mir drei weitere Bytes erspart.

BEARBEITEN 2: Es gibt keine Spezifikation für das Format der Eingabe, daher gehe ich davon aus, dass es für mein Programm passend ist: P

— Hiato
quelle
5

Befunge-93, 85 (Raster: 41 x 3 = 123)

Dies ist eine alte Frage, aber ich dachte, ich würde sie wiederbeleben, um eine etwas schönere Befunge-Antwort zu posten.

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

Sie können es hier testen . Geben Sie jeweils ein einzelnes Zeichen ein. es endet mit der Eingabe von a. Zeichens (Sie können dies ändern, indem Sie "."die rechte Seite der zweiten Zeile ändern ). Funktioniert mit Groß- und Kleinschreibung sowie Interpunktion und ohne Eingabebegrenzung.

Ich erwarte nicht, dass dies eine Menge positive Stimmen oder ähnliches einbringt, aber ich wollte nur demonstrieren, wie großartig Befunge tatsächlich ist dass man es ein bisschen besser machen kann als die andere Antwort.

Ich könnte es in Befunge-98 wahrscheinlich noch kürzer machen.

— Kasran
quelle
Sie können mein Snippet von hier aus hinzufügen , um einen Inline-Interpreter zu haben, wenn Sie möchten. :)
— Ingo Bürk
Oh, ich habe Schnipsel noch nicht wirklich untersucht. Ich werde einen Blick darauf werfen, danke!
— Kasran
Dies funktioniert nicht, wenn die Eingabe ein Leerzeichen enthält. Es geht in der Sequenz in eine Endlosschleife über, >$! _da Sie an dem Punkt, an dem Sie einen Wert ungleich Null erwarten, zwei Nullen auf dem Stapel haben.
— James Holderness
4

PHP - 103 98 80 Zeichen

(ohne str_rot13 ())

<?=preg_replace('#[a-zA-Z]#e','chr(($x=ord("\0"))-$x%32+1+($x%32+12)%26)',`cat`);
— Arnaud Le Blanc
quelle
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
quelle
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.speichert einen Charakter :)
— Wouter van Nifterick
@Wouter van Nifterick: Guter Ort! Ich werde es entsprechend aktualisieren
— PatrickvL
4

Haskell, 100 Zeichen

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

Java 251 Zeichen

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

Python 3 (107)

Ok, ich verspreche, diese Frage jetzt nicht mehr zu beantworten, aber ich fühlte mich gezwungen, die DC-Antwort in Python zu schlagen. Das spiegelt mich als Person wahrscheinlich schlecht wider :).

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 Zeichen

Okay, ich weiß, dass dieser Thread schon lange tot ist, aber ich konnte die (lange) C-Lösung nicht ausstehen, die nicht einmal auf Clang kompiliert (aber auf GCC).

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

Es ist wahrscheinlich fast noch drückbar. Es war auf jeden Fall drückbar. Und es war nicht nur quetschbar, es war auch möglich, es rekursiv zu machen.

— Fors
quelle
3

05AB1E , 13 12 Bytes

Ein Byte gespeichert dank robbie0630 wurde gespeichert

ADu)øJD2äRJ‡

Probieren Sie es online!

Erläuterung

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
quelle
Ich habe dies mit --debugdurchgearbeitet, und es scheint, dass ˜dies in diesem Fall ein No-Op ist und herausgeschnitten werden kann.
— Robbie
@ robbie0630: Stimmt. Keine Ahnung, warum ich das in hatte. Vielen Dank :)
— 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))}))

Diese Lösung löst das Problem, indem dem Zeichencode 13 hinzugefügt wird, wenn sich das betreffende Zeichen in der ersten Hälfte des Alphabets befindet, oder 13 subtrahiert wird, wenn es sich in der zweiten Hälfte befindet.

— Casey Chu
quelle
Sie können speichern 7 Zeichen durch den Ersatz +(c.toLowerCase()<'n'?13:-13))mit -13+26*/[a-m]/i.test(c).
— Jacob
2

CHIQRSX9 + , 1

R

Sie müssen nur das richtige Werkzeug für das Problem verwenden.
CHIQRSX9 + ist Turing-vollständig und kann mit von Standardkanälen lesen und schreiben C.

— Johannes Kuhn
quelle
5
@ nyuszika7h Die Sprache wurde vor dem Verfassen dieser Frage erfunden, ist also gültig.
— Johannes Kuhn
1
Es ist immer noch eines der Dinge, für die es erfunden wurde. Scheint mir zu schummeln.
— Nyuszika7h
7
@ nyuszika7h Und golfscript wurde erfunden, um bei Code-Golf-Herausforderungen zu gewinnen. Denken Sie, dass das auch betrügt?
— Johannes Kuhn
2
@Mego Es ist kaum fair, diese Standards hier anzuwenden, als sie ein Jahr nach dieser Antwort geschrieben wurden.
— Türklinke
2
— Mego
2

C 136 Bytes

Ich hatte noch nie das Gefühl, dass eine meiner Lösungen gut genug ist, um sie hier zu veröffentlichen, aber ich habe sie zum Spaß gemacht und mir gedacht, dass dies mein Einstieg in den Code-Golfsport sein wird.

#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
quelle
4
Willkommen beim Programmieren von Rätseln und beim Code Golf Stack Exchange. Tolle erste Antwort. Und nur zur Veranschaulichung, wir alle fühlen uns manchmal so, wissen nur, dass alles, was Sie erschaffen, irgendwo "gut genug" ist.
— GamrCorps
2
Alles hier auf PPCG ist nur zum Spaß (oder für imaginäre Internet-Punkte) - bitte denken Sie nicht, dass die Arbeit, die Sie geleistet haben, um eine Lösung zu entwickeln, nicht "gut genug" ist
— cat
Danke für all die Unterstützung. Ich denke, etwas zu posten war alles was ich brauchte, um meinen Kopf in Gang zu bringen. Ich werde bald mehr dieser Herausforderungen angehen.
— Tormyst
2

Javascript, 177 Bytes

Dies setzt voraus, dass es zwei Funktionen gibt, print und 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
quelle
2

LispLisp (16.636)

Es tut mir Leid.

((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
  (lisp lisp))
 (((lisp (lisp (lisp (lisp lisp))))
   ((lisp (lisp (lisp lisp)))
    ((lisp (lisp (lisp (lisp lisp))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (((lisp (lisp (lisp (lisp lisp))))
          (((lisp (lisp (lisp (lisp lisp))))
            ((lisp (lisp (lisp lisp)))
             (lisp (lisp (lisp (lisp lisp))))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (lisp (lisp (lisp lisp)))))
            (((lisp (lisp (lisp (lisp lisp))))
              ((lisp (lisp (lisp lisp)))
               (lisp (lisp (lisp (lisp lisp))))))
             (((lisp (lisp (lisp (lisp lisp))))
               ((lisp (lisp (lisp lisp)))
                ((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))))
              (lisp (lisp (lisp lisp))))))))
         ((lisp (lisp (lisp lisp)))
          (lisp (lisp (lisp lisp)))))))
      (((lisp (lisp (lisp (lisp lisp))))
        ((lisp (lisp (lisp lisp)))
         (((lisp (lisp (lisp (lisp lisp))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (lisp (lisp (lisp lisp)))))))
            (((lisp (lisp (lisp (lisp lisp))))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 ((lisp (lisp (lisp lisp)))
                  ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
             ((lisp (lisp (lisp lisp)))
              (((((lisp (lisp (lisp (lisp lisp))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     (lisp (lisp (lisp (lisp lisp))))))
                   (lisp (lisp (lisp lisp)))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp (lisp lisp))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (lisp (lisp (lisp (lisp lisp))))))
                      (lisp (lisp (lisp lisp))))))
                   (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                    (lisp lisp)))
                  (((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (lisp lisp))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                     ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                 (lisp (lisp (lisp lisp)))))
               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 (((lisp (lisp (lisp (lisp lisp))))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp))
                     ((((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         ((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                           ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                       (lisp (lisp (lisp lisp))))))))
                  (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                         (lisp (lisp (lisp lisp))))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       (lisp lisp))))))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         (lisp (lisp (lisp (lisp lisp))))))
                       (lisp (lisp (lisp lisp)))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp))))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp (lisp lisp))))))
                           (lisp (lisp (lisp lisp)))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp))))
                             ((lisp (lisp (lisp lisp)))
                              (lisp (lisp (lisp (lisp lisp))))))
                            (lisp (lisp (lisp lisp)))))
                          (lisp lisp)))))
                      ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                        (lisp lisp))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       ((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                         ((lisp (lisp (lisp lisp)))
                          ((((lisp (lisp (lisp (lisp lisp))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                (lisp (lisp (lisp (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp (lisp lisp))))))
                                  (lisp (lisp (lisp lisp)))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  ((lisp (lisp (lisp lisp)))
                                   (lisp (lisp (lisp (lisp lisp))))))
                                 (lisp (lisp (lisp lisp)))))
                               (lisp lisp)))))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (lisp (lisp (lisp (lisp lisp))))))
                             (lisp (lisp (lisp lisp)))))))))))
                     (lisp (lisp (lisp lisp)))))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (((lisp (lisp (lisp (lisp lisp))))
                     ((lisp (lisp (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp)))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     ((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp lisp)))))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                              ((lisp (lisp (lisp lisp)))
                               ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
                          ((lisp (lisp (lisp lisp)))
                           (((((lisp (lisp (lisp (lisp lisp))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  (lisp (lisp (lisp (lisp lisp))))))
                                (lisp (lisp (lisp lisp)))))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp)))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      ((lisp (lisp (lisp lisp)))
                                       (lisp (lisp (lisp (lisp lisp))))))
                                     (lisp (lisp (lisp lisp)))))
                                   (lisp lisp)))))
                               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                                 (lisp lisp))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                ((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (lisp lisp))
                                  ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 ((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      ((lisp (lisp (lisp (lisp lisp))))
                                       (lisp lisp))))
                                    (lisp (lisp (lisp lisp))))))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp lisp)))))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp lisp)))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      (lisp lisp))
                                     (lisp lisp)))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp))))))))))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))))))))
                   (lisp (lisp (lisp lisp))))))))))))
          (lisp lisp))))
       (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
        ((lisp (lisp (lisp lisp)))
         (lisp (lisp (lisp lisp))))))))))
  (((lisp (lisp (lisp (lisp lisp))))
    (((lisp (lisp (lisp (lisp lisp))))
      ((lisp (lisp (lisp lisp)))
       (lisp (lisp (lisp (lisp lisp))))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (lisp (lisp (lisp lisp)))))
      (((lisp (lisp (lisp (lisp lisp)))) (lisp 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
quelle
Ist das eine tatsächliche Sprache mit einer Implementierung? Wenn ja, können Sie bitte darauf verlinken?
— Jo King
@JoKing Wikipedia TIO
— Benjamin Urquhart
@BenjaminUrquhart Ja, Lisp ist eine Sprache. Lisplisp jedoch habe ich keine Beweise gefunden
— Jo King
@JoKing oh ich verstehe. Vielleicht bezog er sich darauf?
— Benjamin Urquhart
1
Hier ist ein Übersetzer für LazyK (selbst einfach eine Implementierung des SKI Combinator Calculus). gist.github.com/SYZYGY-DEV333/d74ca36b9a4c504b25c0a2380203c98d
— SYZYGY-DEV 333
2

8086 Maschinencode, 27 Bytes

Zerlegt:

        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

Eingabe String in SI, Länge in CX. String-Puffer ausgeben um DI.

Testen Sie die Ausgabe des IBM PC DOS-Programms:

Bildbeschreibung hier eingeben

Laden Sie das Testprogramm R13.COM (PC DOS) herunter .

— 640 KB
quelle
1

Haskell - 112 Zeichen

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 Zeichen

package require [set c tcl::transform::rot];$c 13 stdin;fcopy stdin stdout
— Johannes Kuhn
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.