ROT-13 mentransformasikan input standar

34

Tantangannya: Untuk membaca input yang panjangnya berubah-ubah dan menghasilkan ROT13 dari input tersebut. Semua karakter selain AZ harus disalin ke output kata demi kata, dan case harus dipertahankan jika memungkinkan.

Bahasa apa pun yang dapat membaca dan menulis stream standar adalah permainan yang adil.

code-golf  cryptography 
— MiffTheFox
sumber
3
Masalahnya seharusnya bukan tag, jadi saya menghapus ROT13, hanya FYI
— Nick Berardi
2
Bukankah maksud Anda A-Za-z (untuk menghitung huruf besar dan kecil)?
— Joey Adams
5
@ Chris Jester-Young, ini termasuk dalam kategori ini di wikipedia. Itu bagian dari kriptografi, hanya saja bukan yang tersulit. Lagi pula, saya tidak lagi mengikuti situs ini. Komunitas mengecewakan saya. Maaf. GL HF.
— Nakilon
17
Mengatakan xor bukan enkripsi sama dengan mengatakan + b bukan matematika .
— Nakilon
3
Tag digunakan untuk mengelompokkan pertanyaan dan membantu mencari pertanyaan serupa. The kriptografi tag (dari Kryptos Yunani, "tersembunyi, rahasia", dan graphein, "menulis") khususnya untuk enkripsi dan dekripsi masalah. Semua enkripsi dan dekripsi, tidak hanya yang aman untuk aplikasi modern.
— Angs

Jawaban:

25

Bash, 23 byte

Jawaban 23 karakter Canonical:

tr A-Za-z N-ZA-Mn-za-m
— Chris Jester-Young
sumber
1
Saya tidak memiliki akses ke bash pada saat ini, tetapi saya pikir ini harus bekerja: tr A-za-m N-ZA-z(16 karakter)
— Nabb
2
@Nabb: Senang bertemu Anda, GolfScript-meister! : -DI pikir solusi Anda di sini akan mematahkan ketentuan bahwa "Semua karakter selain AZ harus disalin ke output kata demi kata".
— Chris Jester-Young
@ Chris: Ya, sepertinya Anda benar.
— Nabb
@Nabb: Tidak, bagi saya sepertinya dia salah. Atau mungkin Anda menunjukkan contoh?
— pengguna tidak diketahui
2
@ pengguna tidak dikenal: Ketikkan [\\]^_`input. Itu akan kembali sebagai NOPQRSbukan [\\]^_`, setidaknya dalam versi yang trsaya miliki. (Itu adalah enam karakter dalam ASCII yang terletak di antara Zdan a. Jelas, semua karakter lain akan berfungsi dengan benar.)
— Chris Jester-Young
20

Bash - 5 karakter

rot13

 

— gnibbler
sumber
18
Sejauh ini dua downvotes (tanpa komentar), tetapi tidak ada downvotes untuk pertanyaan tersebut. Saya berasumsi itu berarti tidak apa-apa untuk meminta codegolf sepele tetapi tidak memberikan jawaban sepele. Tolong codegolf yang lebih keras !
— gnibbler
8
Versi bash mana? Saya tidak memiliki built-in rot13. bash --version GNU bash, Version 4.0.33(1)-release (i486-pc-linux-gnu)
— pengguna tidak diketahui
12
Saya akan mengirimkan ini sebagai rot13 - 0 chars...;)
— boothby
2
Coreutils temanku, bukan Bash
— TheDoctor
3
erm ... tidak. bash saya (Ubuntu 13.10) mengatakan "perintah tidak ditemukan, Anda dapat menginstal program ini dengan sudo apt-get install bsdgames"
17

Python 2, 34 byte

print raw_input().encode('rot13')
— Juan
sumber
1
-1 Saya pikir itu curang bahwa Anda menggunakan built-in library.
— Glenn Nelson
16
Saya telah menggunakan mereka dalam setiap kode golf yang saya ikuti ... Juga jika menggunakan lib standar python adalah curang, bagaimana menggunakan tr?
— Juan
3
@Anon Dalam hal apa pun, ini adalah anwser yang Anda abaikan .. Ini bukan dari target, tidak ada aturan yang ditetapkan oleh OP maupun oleh komunitas. Tentu, mungkin milik saya bukan solusi pemenang penghargaan, seperti yang menggunakan tr yang menendang pantat. Tapi ini bukan lelucon, saya meningkatkan kekuatan python untuk mengurangi jumlah, sama seperti yang lain.
— Juan
2
@ Glenn: sebaliknya, saya belum pernah melihat hal kode-golf yang mengatakan demikian. Begitu pula codegolf.com, golf.shinh.org atau SPOJ SHORTEN.
— hallvabo
9
@ Glenn, saya pikir fungsi perpustakaan adalah permainan yang adil. Pertanyaan golf cukup menarik untuk tidak ada di perpustakaan siapa pun atau untuk secara khusus dikecualikan.
— gnibbler
15

Befunge - 7x30 = 210 6x26 = 156 karakter

Versi streaming baru yang mendukung huruf besar dan kecil dan harus mendukung input tanpa batas.

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

Versi lama

Ini menyimpan nilai-nilai di dalam kode sumbernya sendiri. Benar-benar menunjukkan betapa mengerikannya untuk mencoba dan menampilkan nilai yang disimpan dalam urutan yang sama dengan yang Anda terima. Hanya mendukung karakter huruf kecil.

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

Saya tidak yakin persis batasan apa yang dimilikinya, menggunakan http://www.quirkster.com/iano/js/befunge.html sebagai penerjemah yang tampaknya tidak dapat diakses dengan input besar.

— Nemo157
sumber
Anda dapat menghapus spasi putih di akhir baris.
— Zacharý
10

Ruby - 60 57 38 37 karakter

Sunting: Dan baru menyadari string Ruby memiliki trmetode.

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

Uji

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

Memberi:

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
sumber
Anda tidak perlu ruang setelahnya puts, dan 'Az' adalah jalan pintas untuk 'A-Za-z'
— Ventero
1
@Ventro: Terima kasih, setelah sedikit pengujian tampaknya 'A-z'sebenarnya 'A-Z[\]^_a-z ' , damn ascii having characters between Z` dan a.
— Nemo157
1
Dasarnya sama tapi 35 karakter: puts gets.tr'A-Za-z','N-ZA-Mn-za-m'.
— Michael Kohl
@Michael: Kecuali getshanya mengembalikan baris pertama, menggunakan $ <. Read dibaca sampai EOF. Pertanyaannya tidak mengatakan apa-apa tentang apakah input dapat berisi baris baru jadi saya hanya salah hati-hati.
— Nemo157
Cukup adil, tetapi karena spesifikasi latihan hanya menyebutkan "panjang arbitrer" tetapi tidak mengatakan apa-apa tentang baris baru, saya lebih suka berbuat salah di sisi keringkasan dalam codegolf ;-)
— Michael Kohl
10

vim, 5 penekanan tombol

Dengan asumsi mode normal dan teks sudah ditulis dalam buffer:

ggg?G

Atau, mengalah konvensi vimgolf:

g?GZZ

Anda juga dapat menjalankannya sebagai perintah terminal, seperti ini:

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

Saya kira yang terakhir akan dihitung sebagai "program" 8 karakter ( norm g?G)

— daniero
sumber
norm g?Gkependekan untuk normal g?Gyang membuat 8 karakter.
— Patrick Oscity
Saya pikir Anda dapat dengan aman berasumsi untuk memulai pada baris 1, sehingga yang pertama ggdapat ditinggalkan. Saya akan mengatakan 3 penekanan tombol ketika file terbuka.
— Patrick Oscity
1
Jika kita menggunakan konvensi vimgolf (Anda mulai dalam vim vanila yang baru saja membuka file, tetapi perlu menyimpan dan keluar) kami juga mendapatkan 5 ( g?GZZ).
— FireFly
7

C - 83 79 karakter

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

Versi yang dapat dibaca:

#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
sumber
1
Apakah Anda menyertakan tajuk yang Anda masukkan dalam hitungan?
— JPvdMerwe
@JPvdMerwe: Saya tidak memasukkan header dalam versi golf, saya juga tidak perlu.
— Joey Adams
Anda dapat menggunakan operator koma sebelum putchar untuk melepaskan sepasang kawat gigi.
— Alexandru
Bisakah Anda menjelaskan main (c, b)? Ini pertama kalinya saya melihat ini.
— Alexandru
2
@Alexandru kebanyakan kompiler C mendukung main dengan parameter apa pun. Juga, standar C asli mendefinisikan bahwa argumen tanpa tipe adalah int. Dengan demikian Anda bisa mendeklarasikan int tanpa benar-benar menulis int.
— Juan
7

Python (117 byte)

Ini adalah versi Python yang menghindari rot13()-metode.

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
sumber
raw_input mengembalikan satu baris tidak semua input.
— Alexandru
Anda perlu import sysdan gunakan sys.stdin.read().
— Alexandru
@Alexandru: akan lakukan
— JPvdMerwe
-2 byte jika Anda menghilangkan []untuk membuat daftar comp generator: tio.run/…
— connectyourcharger
7

tr///solusi dalam Perl (39 karakter), boilerplate dapat dihilangkan dengan -p:

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

Menggunakan -p(23 karakter termasuk sakelar tambahan):

perl -pe'y/a-zA-Z/n-za-mN-ZA-M/'
— Segera.
sumber
Tambahkan 1 char untuk p, tapi tolong lepaskan boilerplate!
— JB
7

R, 37 byte

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

example("chartr")menjalankan contoh untuk chartr, yang meliputi rotfungsi, yang secara ROT13default ....

— mnel
sumber
5

DC ( 111 108 untuk dc itu sendiri)

Ok, ini dia di (kebanyakan) dc dan beberapa sihir sed dan od untuk mendapatkannya ke format yang tepat untuk kode. Jika Anda tidak menghitung hal input ( echo -n MESSAGE |) itu 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'

Yang menarik, program dc itu sendiri hanya panjang 108 byte , lebih pendek dari versi python non-perpustakaan. Ia bahkan mempertahankan case dan tanda baca, dan mengalahkan Javascript dalam pengiriman di atas! Kalau saja saya bisa mengurai output od lebih baik, atau lebih baik lagi menggantinya sama sekali.

EDIT: Perlu dicatat bahwa pertanyaan itu tidak menunjukkan baris baru tertinggal 10Pyang menyelamatkan saya tiga byte lebih lanjut.

EDIT 2: Tidak ada spesifikasi untuk format input, jadi saya menganggap itu diambil karena nyaman untuk program saya: P

— Hiato
sumber
5

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

Ini adalah pertanyaan kuno, tapi saya pikir saya akan menghidupkannya kembali untuk mengirim jawaban Befunge yang sedikit lebih baik.

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

Anda bisa mengujinya di sini . Masukkan satu karakter pada satu waktu; itu berakhir saat memasukkan .karakter (Anda dapat mengubahnya dengan memodifikasi "."dekat sisi kanan baris kedua). Bekerja dengan huruf besar dan kecil, serta tanda baca, dan tanpa batas input.

Saya tidak berharap ini mendapatkan satu ton upvotes atau apa pun, tapi saya hanya ingin menunjukkan betapa luar biasanya Befunge adalah bahwa Anda dapat melakukan sedikit lebih baik daripada jawaban lainnya.

Saya mungkin bisa membuatnya lebih pendek di Befunge-98.

— Kasran
sumber
Anda dapat menambahkan cuplikan saya dari sini untuk memiliki juru bahasa inline, jika Anda mau. :)
— Ingo Bürk
Ooh, saya belum benar-benar menyelidiki cuplikan. Saya akan memeriksanya, terima kasih!
— Kasran
Ini tidak berfungsi jika ada ruang di input. Ini masuk ke loop tak terbatas dalam urutan >$! _karena Anda punya dua nol pada tumpukan pada saat itu ketika Anda mengharapkan nilai bukan nol.
— James Holderness
4

PHP - 103 98 80 karakter

(tidak menggunakan str_rot13 ())

<?=preg_replace('#[a-zA-Z]#e','chr(($x=ord("\0"))-$x%32+1+($x%32+12)%26)',`cat`);
— Arnaud Le Blanc
sumber
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
sumber
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.menghemat satu karakter :)
— Wouter van Nifterick
@Wouter van Nifterick: Tempat yang bagus! Saya akan memperbaruinya
— Patrickv
4

Haskell, 100 karakter

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

Java 251 karakter

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

Python 3 (107)

Oke, saya berjanji untuk berhenti menjawab pertanyaan ini sekarang, tetapi saya merasa harus mengalahkan jawaban DC dengan Python. Ini mungkin mencerminkan buruk pada saya sebagai pribadi :).

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 karakter

Baiklah, saya tahu utas ini sudah lama mati, tapi saya tidak tahan dengan solusi-C (panjang) yang bahkan tidak dapat dikompilasi pada Dentang (tetapi tidak pada GCC).

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

Ini mungkin hampir masih dapat dipecahkan. Itu pasti bisa dipadamkan. Dan itu tidak hanya dapat dipadamkan, tetapi juga memungkinkan untuk membuatnya rekursif.

— Fors
sumber
3

05AB1E , 13 12 byte

Menyimpan satu byte berkat robbie0630

ADu)øJD2äRJ‡

Cobalah online!

Penjelasan

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
sumber
Aku berlari melalui ini --debug, dan sepertinya itu ˜adalah no-op dalam hal ini dan dapat dihentikan.
— robbie
@ robbie0630: Benar. Tidak tahu mengapa saya memilikinya. Terima kasih :)
— 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))}))

Solusi ini menyelesaikan masalah dengan menambahkan 13 ke kode karakter jika karakter tersebut di bagian pertama dari alfabet, atau mengurangi 13 jika di bagian kedua.

— Casey Chu
sumber
Anda dapat menyimpan 7 karakter dengan mengganti +(c.toLowerCase()<'n'?13:-13))dengan -13+26*/[a-m]/i.test(c).
— Yakub
2

CHIQRSX9 + , 1

R

Anda hanya perlu menggunakan alat yang tepat untuk masalah tersebut.
CHIQRSX9 + adalah Turing yang lengkap, dan dapat membaca dan menulis dari saluran standar dengan C.

— Johannes Kuhn
sumber
5
@ nyuszika7h Bahasa ini ditemukan sebelum pertanyaan ini ditulis, jadi itu valid.
— Johannes Kuhn
1
Itu masih salah satu hal yang diciptakan untuk itu. Sepertinya selingkuh bagiku.
— nyuszika7h
7
@ nyuszika7h Dan golfscript diciptakan untuk menang dalam tantangan kode-golf. Apakah Anda pikir itu curang juga?
— Johannes Kuhn
2
@Mego Tidak adil untuk menerapkan standar-standar itu di sini ketika standar itu ditulis setahun setelah jawaban ini.
— Gagang Pintu
2
— Mego
2

C, 136 byte

Saya tidak pernah merasa ada solusi yang cukup baik untuk dikirim di sini, tetapi membuat ini untuk bersenang-senang, dan berpikir bahwa itu akan menjadi obat gerbang saya ke dalam kode 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
sumber
4
Selamat datang di Programming Puzzles dan Code Golf Stack Exchange. Jawaban pertama yang bagus. Dan sebagai catatan, kadang-kadang kita semua merasa seperti itu, hanya tahu bahwa apa pun yang Anda buat "cukup baik" di suatu tempat.
— GamrCorps
2
Segala sesuatu di sini di PPCG hanya untuk bersenang-senang (atau poin internet imajiner) - tolong, jangan merasa pekerjaan yang Anda lakukan untuk membuat solusi tidak "cukup baik"
— cat
Terima kasih atas semua dukungannya. Saya pikir posting sesuatu yang saya butuhkan untuk mendapatkan kepala saya di gigi. Saya akan segera mencoba tantangan ini.
— Tormyst
2

Javascript, 177 byte

Ini mengasumsikan bahwa ada dua fungsi, cetak dan bacaLine:

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
sumber
2

LispLisp (16.636)

Maafkan saya.

((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
  (lisp lisp))
 (((lisp (lisp (lisp (lisp lisp))))
   ((lisp (lisp (lisp lisp)))
    ((lisp (lisp (lisp (lisp lisp))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (((lisp (lisp (lisp (lisp lisp))))
          (((lisp (lisp (lisp (lisp lisp))))
            ((lisp (lisp (lisp lisp)))
             (lisp (lisp (lisp (lisp lisp))))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (lisp (lisp (lisp lisp)))))
            (((lisp (lisp (lisp (lisp lisp))))
              ((lisp (lisp (lisp lisp)))
               (lisp (lisp (lisp (lisp lisp))))))
             (((lisp (lisp (lisp (lisp lisp))))
               ((lisp (lisp (lisp lisp)))
                ((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))))
              (lisp (lisp (lisp lisp))))))))
         ((lisp (lisp (lisp lisp)))
          (lisp (lisp (lisp lisp)))))))
      (((lisp (lisp (lisp (lisp lisp))))
        ((lisp (lisp (lisp lisp)))
         (((lisp (lisp (lisp (lisp lisp))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (lisp (lisp (lisp lisp)))))))
            (((lisp (lisp (lisp (lisp lisp))))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 ((lisp (lisp (lisp lisp)))
                  ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
             ((lisp (lisp (lisp lisp)))
              (((((lisp (lisp (lisp (lisp lisp))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     (lisp (lisp (lisp (lisp lisp))))))
                   (lisp (lisp (lisp lisp)))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp (lisp lisp))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (lisp (lisp (lisp (lisp lisp))))))
                      (lisp (lisp (lisp lisp))))))
                   (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                    (lisp lisp)))
                  (((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (lisp lisp))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                     ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                 (lisp (lisp (lisp lisp)))))
               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 (((lisp (lisp (lisp (lisp lisp))))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp))
                     ((((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         ((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                           ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                       (lisp (lisp (lisp lisp))))))))
                  (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                         (lisp (lisp (lisp lisp))))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       (lisp lisp))))))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         (lisp (lisp (lisp (lisp lisp))))))
                       (lisp (lisp (lisp lisp)))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp))))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp (lisp lisp))))))
                           (lisp (lisp (lisp lisp)))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp))))
                             ((lisp (lisp (lisp lisp)))
                              (lisp (lisp (lisp (lisp lisp))))))
                            (lisp (lisp (lisp lisp)))))
                          (lisp lisp)))))
                      ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                        (lisp lisp))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       ((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                         ((lisp (lisp (lisp lisp)))
                          ((((lisp (lisp (lisp (lisp lisp))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                (lisp (lisp (lisp (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp (lisp lisp))))))
                                  (lisp (lisp (lisp lisp)))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  ((lisp (lisp (lisp lisp)))
                                   (lisp (lisp (lisp (lisp lisp))))))
                                 (lisp (lisp (lisp lisp)))))
                               (lisp lisp)))))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (lisp (lisp (lisp (lisp lisp))))))
                             (lisp (lisp (lisp lisp)))))))))))
                     (lisp (lisp (lisp lisp)))))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (((lisp (lisp (lisp (lisp lisp))))
                     ((lisp (lisp (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp)))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     ((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp lisp)))))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                              ((lisp (lisp (lisp lisp)))
                               ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
                          ((lisp (lisp (lisp lisp)))
                           (((((lisp (lisp (lisp (lisp lisp))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  (lisp (lisp (lisp (lisp lisp))))))
                                (lisp (lisp (lisp lisp)))))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp)))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      ((lisp (lisp (lisp lisp)))
                                       (lisp (lisp (lisp (lisp lisp))))))
                                     (lisp (lisp (lisp lisp)))))
                                   (lisp lisp)))))
                               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                                 (lisp lisp))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                ((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (lisp lisp))
                                  ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 ((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      ((lisp (lisp (lisp (lisp lisp))))
                                       (lisp lisp))))
                                    (lisp (lisp (lisp lisp))))))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp lisp)))))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp lisp)))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      (lisp lisp))
                                     (lisp lisp)))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp))))))))))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))))))))
                   (lisp (lisp (lisp lisp))))))))))))
          (lisp lisp))))
       (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
        ((lisp (lisp (lisp lisp)))
         (lisp (lisp (lisp lisp))))))))))
  (((lisp (lisp (lisp (lisp lisp))))
    (((lisp (lisp (lisp (lisp lisp))))
      ((lisp (lisp (lisp lisp)))
       (lisp (lisp (lisp (lisp lisp))))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (lisp (lisp (lisp lisp)))))
      (((lisp (lisp (lisp (lisp lisp)))) (lisp 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
sumber
Apakah ini bahasa aktual dengan implementasi? Jika demikian, dapatkah Anda menautkan ke sana?
— Jo King
@JoKing Wikipedia TIO
— Benjamin Urquhart
@BenjaminUrquhart Ya, Lisp adalah bahasa. Namun Lisplisp, saya tidak menemukan bukti ada
— Jo King
@ Bersenang-senang oh saya mengerti. Mungkin dia mengacu pada ini?
— Benjamin Urquhart
1
Berikut ini adalah penerjemah ke LazyK (Itu sendiri hanyalah implementasi dari Kalkulus Combinator SKI). gist.github.com/SYZYGY-DEV333/d74ca36b9a4c504b25c0a2380203c98d
— SYZYGY-DEV 333
2

8086 Kode Mesin, 27 byte

Belum dirakit:

        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

Masukkan string SI, panjang CX. Output string buffer di DI.

Uji output program IBM PC DOS:

masukkan deskripsi gambar di sini

Unduh program uji R13.COM (PC DOS).

— 640KB
sumber
1

Haskell - 112 karakter

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 karakter

package require [set c tcl::transform::rot];$c 13 stdin;fcopy stdin stdout
— Johannes Kuhn
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.