34

Thách thức: Để đọc một đầu vào có độ dài tùy ý và tạo ROT13 của đầu vào. Tất cả các ký tự ngoài AZ nên được sao chép vào nguyên văn đầu ra và trường hợp nên được giữ nguyên nếu có thể.

Bất kỳ ngôn ngữ có thể đọc và viết các luồng tiêu chuẩn là trò chơi công bằng.

code-golf cryptography

— MiffTheFox
nguồn

3

Vấn đề không phải là một thẻ, vì vậy tôi đã xóa ROT13, chỉ là một FYI

— Nick Berardi

2

Ý bạn là A-Za-z (để tính cả chữ hoa và chữ thường)?

— Joey Adams

5

@Chris Jester-Young, nó thuộc thể loại này tại wikipedia. Đó là một phần của mật mã, không phải là khó nhất. Dù sao, tôi không còn theo dõi trang web này nữa. Cộng đồng làm tôi thất vọng. Lấy làm tiếc. GL HF.

— Nakilon

17

Nói xor không mã hóa cũng giống như nói a + b không phải là toán học .

— Nakilon

3

Thẻ được sử dụng để phân loại câu hỏi và giúp tìm kiếm các câu hỏi tương tự. Các mật mã thẻ (từ Kryptos Hy Lạp, "ẩn, bí mật"; và graphein, "viết") đặc biệt là đối với các vấn đề mã hóa và giải mã. Tất cả mã hóa và giải mã, không chỉ những thứ an toàn cho các ứng dụng hiện đại.

— Angs

25

Bash, 23 byte

Canonical trả lời 23 ký tự:

tr A-Za-z N-ZA-Mn-za-m

— Chris Jester-Young
nguồn

1

Hiện tại tôi không có quyền truy cập vào bash, nhưng tôi nghĩ rằng nó sẽ hoạt động: tr A-za-m N-ZA-z(16 ký tự)

— Nabb

2

@Nabb: Rất vui được gặp bạn, GolfScript-meister! : -DI nghĩ rằng giải pháp của bạn ở đây sẽ phá vỡ quy định rằng "Tất cả các ký tự ngoài AZ nên được sao chép vào nguyên văn đầu ra".

— Chris Jester-Young

@Chris: Đúng, có vẻ như bạn đúng.

— Nabb

@Nabb: Không, với tôi có vẻ như anh ấy sai. Hoặc bạn có thể đưa ra một ví dụ?

— người dùng không xác định

2

@user unknown: Nhập [\\]^_`vào đầu vào. Nó sẽ trở lại NOPQRSthay vì [\\]^_`, ít nhất là trong phiên bản trtôi có. (Đó là sáu nhân vật trong ASCII nằm giữa Zvà a. Rõ ràng, tất cả các nhân vật khác sẽ hoạt động chính xác.)

— Chris Jester-Young

20

Bash - 5 ký tự

rot13

— gặm nhấm
nguồn

18

Hai downvote cho đến nay (không có bình luận), nhưng không có downvote cho câu hỏi. Tôi cho rằng điều đó có nghĩa là không sao khi hỏi các codegolf tầm thường nhưng không đưa ra câu trả lời tầm thường. Codegolfs cứng hơn xin vui lòng!

— gnibbler

8

Phiên bản bash nào? Tôi không có rot13 tích hợp. bash --version GNU bash, Version 4.0.33(1)-release (i486-pc-linux-gnu)

— người dùng không xác định

12

Tôi đã gửi cái này dưới dạng rot13 - 0 chars...;)

— boothby

2

'tis coreutils bạn của tôi, không phải Bash

— TheDoctor

3

erm ... không. bash của tôi (Ubuntu 13.10) nói rằng "không tìm thấy lệnh, bạn có thể cài đặt chương trình này bằng cách sudo apt-get install bsdgames"

17

Python 2, 34 byte

print raw_input().encode('rot13')

— Juan
nguồn

1

-1 Tôi nghĩ thật gian lận khi bạn đang sử dụng một thư viện tích hợp.

— Glenn Nelson

16

Tôi đã sử dụng chúng trong mọi mã golf tôi tham gia ... Ngoài ra, nếu sử dụng lib tiêu chuẩn của python là gian lận, làm thế nào để sử dụng tr không?

— Juan

3

@Anon Trong mọi trường hợp, đó là một anwser bạn chỉ cần bỏ qua .. Nó không nằm ngoài mục tiêu, không có bất kỳ quy tắc nào được đặt ra bởi OP cũng như bởi cộng đồng. Chắc chắn, có lẽ của tôi không phải là một giải pháp giành giải thưởng, giống như giải pháp sử dụng tr mà đá đít. Nhưng đó không phải là một trò đùa, tôi tận dụng sức mạnh của trăn để giảm số lượng, giống như bất kỳ ai khác sẽ làm.

— Juan

2

@Glenn: ngược lại, tôi chưa bao giờ thấy một thứ golf-code nào nói như vậy. Cả codegolf.com, golf.shinh.org hay SPOJ SHORTEN cũng không.

— hallvabo

9

@Glenn, tôi nghĩ chức năng thư viện là trò chơi công bằng. Câu hỏi golf đủ thú vị để không có trong thư viện của bất kỳ ai hoặc loại trừ cụ thể.

— gnibbler

15

Befunge - 7x30 = 210 6x26 = 156 ký tự

Phiên bản phát trực tuyến mới hỗ trợ cả chữ hoa và chữ thường và nên hỗ trợ đầu vào không giới hạn.

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

Phiên bản cũ

Điều này lưu trữ các giá trị bên trong mã nguồn riêng của nó. Thực sự cho thấy thật kinh khủng khi thử và xuất các giá trị được lưu trữ theo cùng thứ tự mà bạn nhận được chúng. Chỉ hỗ trợ các ký tự chữ thường.

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

Tôi không chắc chắn chính xác những hạn chế này, sử dụng http://www.quirkster.com/iano/js/befunge.html làm trình thông dịch có vẻ như bị hỏng với các đầu vào lớn.

— Nemo157
nguồn

Bạn có thể xóa khoảng trắng ở cuối dòng.

— Zacharý

10

Ruby - 60 57 38 37 ký tự

Chỉnh sửa: Và chỉ cần nhận ra chuỗi Ruby có một trphương thức.

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

Kiểm tra

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

Cung cấp:

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
nguồn

Bạn không cần khoảng trống sau putsvà 'Az' là lối tắt cho 'A-Za-z'

— Ventero

1

@Ventro: Cảm ơn, sau một chút thử nghiệm, có vẻ như đó 'A-z'thực sự 'A-Z[\]^_là a-z ' , damn ascii having characters between Z` và a.

— Nemo157

1

Về cơ bản giống nhau nhưng 35 ký tự : puts gets.tr'A-Za-z','N-ZA-Mn-za-m'.

— Michael Kohl

@Michael: Ngoại trừ getschỉ trả về dòng đầu tiên, sử dụng $ <. Read đọc cho đến khi EOF. Câu hỏi không nói lên điều gì về việc liệu đầu vào có thể chứa các dòng mới hay không, vì vậy tôi chỉ thận trọng.

— Nemo157

Đủ công bằng, nhưng vì đặc tả bài tập chỉ đề cập đến "độ dài tùy ý" nhưng không nói gì về dòng mới, tôi khá sai lầm về mặt ngắn gọn trong codegolf ;-)

— Michael Kohl

10

vim, 5 tổ hợp phím

Giả sử chế độ bình thường và văn bản đã được ghi trong bộ đệm:

ggg?G

Hoặc, các quy ước của vimgolf rơi xuống:

g?GZZ

Bạn cũng có thể gọi nó như một lệnh đầu cuối, đại loại như thế này:

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

Tôi đoán cái sau sẽ được tính là một "chương trình" gồm 8 ký tự ( norm g?G)

— daniero
nguồn

norm g?Glà viết tắt của normal g?G8 ký tự.

— Patrick Oscarity

Tôi nghĩ rằng bạn có thể giả định một cách an toàn để bắt đầu trên dòng 1, vì vậy đầu tiên ggcó thể được bỏ qua. Tôi sẽ nói 3 lần nhấn phím khi tệp được mở.

— Patrick Oscarity

1

Nếu chúng tôi sử dụng các quy ước của vimgolf (bạn bắt đầu bằng một vani vim vừa mở tệp, nhưng cần lưu và thoát), chúng tôi cũng nhận được 5 ( g?GZZ).

— FireFly

7

C - 83 79 ký tự

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

Phiên bản dễ đọc:

#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
nguồn

1

Bạn có bao gồm các tiêu đề bạn bao gồm trong số của bạn?

— JPvdMerwe

@JPvdMerwe: Tôi không bao gồm bất kỳ tiêu đề nào trong phiên bản chơi gôn, tôi cũng không cần.

— Joey Adams

Bạn có thể sử dụng toán tử hôn mê trước khi putar để loại bỏ một cặp niềng răng.

— Alexandru

Bạn có thể giải thích chính (c, b)? Đây là lần đầu tiên tôi thấy điều này.

— Alexandru

2

@Alexandru hầu hết các trình biên dịch C hỗ trợ chính với bất kỳ tham số nào. Ngoài ra, tiêu chuẩn C ban đầu xác định rằng một đối số không có kiểu là int. Vì vậy, bạn có thể khai báo int mà không thực sự viết int.

— Juan

7

Python (117 byte)

Đây là phiên bản Python tránh rot13()-method.

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
nguồn

raw_input trả về một dòng không phải tất cả đầu vào.

— Alexandru

bạn cần import sysvà sử dụng sys.stdin.read().

— Alexandru

@Alexandru: sẽ làm

— JPvdMerwe

-2 byte nếu bạn loại bỏ []để tạo danh sách, hãy tạo một trình tạo: tio.run/ từ

— Connectyourcharger

7

tr///giải pháp trong Perl (39 ký tự), có thể loại bỏ bản tóm tắt bằng -p:

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

Sử dụng -p(23 ký tự bao gồm cả công tắc phụ):

perl -pe'y/a-zA-Z/n-za-mN-ZA-M/'

— Anon.
nguồn

Thêm 1 char cho p, nhưng vui lòng loại bỏ cái nồi hơi!

— JB

7

R, 37 byte

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

example("chartr")chạy các ví dụ cho chartr, bao gồm rothàm, ROT13theo mặc định ....

— mnel
nguồn

5

DC ( ~~111~~ 108 cho chính dc)

Ok, đây là (phần lớn) dc và một số phép thuật sed và od để đưa nó vào đúng định dạng cho mã. Nếu bạn không đếm thứ đầu vào ( echo -n MESSAGE |) thì đó là 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'

Như một điểm đáng chú ý, bản thân chương trình dc chỉ dài 108 byte , ngắn hơn phiên bản python không phải thư viện. Nó thậm chí còn bảo vệ trường hợp và dấu câu, và đánh bại Javascript trong bài nộp ở trên! Giá như tôi có thể phân tích cú pháp đầu ra của od tốt hơn, hoặc tốt hơn là thay thế nó hoàn toàn.

EDIT: Điều đáng chú ý là câu hỏi không chỉ ra một dòng mới kéo dài 10Pgiúp tôi tiết kiệm thêm ba byte.

EDIT 2: Không có thông số kỹ thuật cho định dạng của đầu vào, vì vậy tôi cho rằng nó được sử dụng vì thuận tiện cho chương trình của tôi: P

— Hiato
nguồn

5

Befunge-93, 85 (lưới: 41x3 = 123)

Đây là một câu hỏi cổ xưa, nhưng tôi nghĩ tôi sẽ hồi sinh nó để đăng một câu trả lời Befunge đẹp hơn một chút.

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

Bạn có thể kiểm tra nó ở đây . Nhập một ký tự tại một thời điểm; nó chấm dứt khi nhập một .ký tự (bạn có thể thay đổi điều đó bằng cách sửa đổi "."gần bên phải của hàng thứ hai). Hoạt động với chữ hoa và chữ thường, cũng như dấu câu và không giới hạn đầu vào.

Tôi không mong đợi điều này sẽ nhận được rất nhiều ý kiến hay bất cứ điều gì, nhưng tôi chỉ muốn chứng minh ~~rằng Befunge thực sự tuyệt vời như thế nào~~ mà bạn có thể làm tốt hơn một chút so với câu trả lời khác.

Tôi có lẽ có thể làm cho nó thậm chí còn ngắn hơn trong Befunge-98.

— Kasran
nguồn

Bạn có thể thêm đoạn mã của tôi từ đây để có một trình thông dịch nội tuyến, nếu bạn muốn. :)

— Ingo Bürk

Ồ, tôi chưa thực sự điều tra đoạn trích nào. Tôi sẽ xem, cảm ơn!

— Kasran

Điều này không hoạt động nếu có một khoảng trống trong đầu vào. Nó đi vào một vòng lặp vô hạn trong chuỗi >$! _vì bạn đã có hai số không trên ngăn xếp tại thời điểm đó khi bạn đang mong đợi một giá trị khác không.

— James Holdiness

4

PHP - 103 98 80 ký tự

(không sử dụng str_rot13 ())

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

— Arnaud Le Blanc
nguồn

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
nguồn

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.lưu một ký tự :)

— Wouter van Nifterick

@Wouter van Nifterick: Điểm tốt! Tôi sẽ cập nhật nó cho phù hợp

— PatrickvL

4

Haskell, 100 ký tự

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

— MtnViewMark
nguồn

3

Perl6 (54)

$*IN.lines».trans("a..zA..Z"=>"n..za..mN..ZA..M").say

— Bruce Armstrong
nguồn

3

Java chars

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
nguồn

3

Con trăn 3 (107)

Ok, tôi hứa sẽ ngừng trả lời câu hỏi này ngay bây giờ, nhưng tôi cảm thấy bắt buộc phải đánh bại câu trả lời DC bằng Python. Điều này có lẽ phản ánh kém về tôi như một người :).

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 ký tự

Được rồi, tôi biết chủ đề này đã chết từ lâu, nhưng tôi không thể chịu được giải pháp C (dài) thậm chí không biên dịch trên Clang (nhưng trên GCC).

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

~~Nó có lẽ gần như vẫn còn có thể bóp được.~~ Nó chắc chắn là có thể bóp được. Và không chỉ có thể bóp được, nó còn có thể làm cho nó đệ quy.

— Fors
nguồn

3

05AB1E , 13 12 byte

Đã lưu một byte nhờ robbie0630

ADu)øJD2äRJ‡

Hãy thử trực tuyến!

Giải trình

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

— Biểu tượng
nguồn

Tôi đã chạy qua điều này với --debug, và có vẻ như ˜là không có trong trường hợp này và có thể bị cắt bỏ.

— robbie

@ robbie0630: Đúng. Không biết tại sao tôi lại có nó. Cảm ơn bạn :)

— Emigna

2

PHP - 41 ký tự

while($r=fgets(STDIN))echo str_rot13($r);

— ircmaxell
nguồn

5

-1 cho rep-whelling.

— Raynos

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))}))

Giải pháp này giải quyết vấn đề bằng cách thêm 13 vào mã ký tự nếu ký tự trong câu hỏi nằm ở nửa đầu của bảng chữ cái hoặc trừ 13 nếu nó ở nửa sau.

— Casey Chu
nguồn

Bạn có thể lưu 7 ký tự bằng cách thay thế +(c.toLowerCase()<'n'?13:-13))bằng -13+26*/[a-m]/i.test(c).

— Jacob

2

CHIQRSX9 + , 1

Bạn chỉ cần sử dụng đúng công cụ cho vấn đề.
CHIQRSX9 + đã hoàn thành Turing và nó có thể đọc và ghi từ các kênh tiêu chuẩn với C.

— Julian Kuhn
nguồn

5

@ nyuszika7h Ngôn ngữ được phát minh trước khi câu hỏi này được viết, vì vậy nó là hợp lệ.

— Julian Kuhn

1

Tuy nhiên, đây vẫn là một trong những thứ được phát minh ra. Có vẻ như gian lận với tôi.

— nyuszika7h

7

@ nyuszika7h Và golfscript đã được phát minh để giành chiến thắng trong các thử thách chơi gôn. Bạn có nghĩ rằng đó là gian lận quá?

— Julian Kuhn

2

@Mego Thật không công bằng khi áp dụng các tiêu chuẩn đó ở đây khi chúng được viết một năm sau câu trả lời này.

— Doorknob

2

MetaGolfScript bị cấm theo một quy tắc khác

— Mego

2

C, 136 byte

Tôi chưa bao giờ cảm thấy như bất kỳ giải pháp nào của tôi đủ tốt để đăng lên đây, nhưng làm cho nó vui, và hình dung rằng nó sẽ là liều thuốc của tôi vào môn đánh gôn.

#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
nguồn

4

Chào mừng bạn đến với Câu đố lập trình và trao đổi mã Golf. Câu trả lời tuyệt vời đầu tiên. Và chỉ để ghi lại, đôi khi tất cả chúng ta đều cảm thấy như vậy, chỉ cần biết rằng bất cứ điều gì bạn tạo ra là "đủ tốt" ở đâu đó.

— GamrCorps

2

Mọi thứ ở đây trên PPCG chỉ là để giải trí (hoặc các điểm internet tưởng tượng) - xin vui lòng, đừng cảm thấy công việc bạn đã làm để tạo ra một giải pháp không "đủ tốt"

— mèo

Cảm ơn tất cả mọi người vì đã ủng hộ tôi. Tôi nghĩ rằng đăng một cái gì đó là tất cả những gì tôi cần để có được đầu của mình trong thiết bị. Tôi sẽ sớm thử sức mình với những thử thách này.

— Tormyst

2

Javascript, 177 byte

Điều này giả định rằng có hai chức năng, in và 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
nguồn

2

LispLisp (16.636)

Tôi xin lôi.

((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
  (lisp lisp))
 (((lisp (lisp (lisp (lisp lisp))))
   ((lisp (lisp (lisp lisp)))
    ((lisp (lisp (lisp (lisp lisp))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (((lisp (lisp (lisp (lisp lisp))))
          (((lisp (lisp (lisp (lisp lisp))))
            ((lisp (lisp (lisp lisp)))
             (lisp (lisp (lisp (lisp lisp))))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (lisp (lisp (lisp lisp)))))
            (((lisp (lisp (lisp (lisp lisp))))
              ((lisp (lisp (lisp lisp)))
               (lisp (lisp (lisp (lisp lisp))))))
             (((lisp (lisp (lisp (lisp lisp))))
               ((lisp (lisp (lisp lisp)))
                ((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))))
              (lisp (lisp (lisp lisp))))))))
         ((lisp (lisp (lisp lisp)))
          (lisp (lisp (lisp lisp)))))))
      (((lisp (lisp (lisp (lisp lisp))))
        ((lisp (lisp (lisp lisp)))
         (((lisp (lisp (lisp (lisp lisp))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (lisp (lisp (lisp lisp)))))))
            (((lisp (lisp (lisp (lisp lisp))))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 ((lisp (lisp (lisp lisp)))
                  ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
             ((lisp (lisp (lisp lisp)))
              (((((lisp (lisp (lisp (lisp lisp))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     (lisp (lisp (lisp (lisp lisp))))))
                   (lisp (lisp (lisp lisp)))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp (lisp lisp))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (lisp (lisp (lisp (lisp lisp))))))
                      (lisp (lisp (lisp lisp))))))
                   (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                    (lisp lisp)))
                  (((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (lisp lisp))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                     ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                 (lisp (lisp (lisp lisp)))))
               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 (((lisp (lisp (lisp (lisp lisp))))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp))
                     ((((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         ((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                           ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                       (lisp (lisp (lisp lisp))))))))
                  (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                         (lisp (lisp (lisp lisp))))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       (lisp lisp))))))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         (lisp (lisp (lisp (lisp lisp))))))
                       (lisp (lisp (lisp lisp)))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp))))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp (lisp lisp))))))
                           (lisp (lisp (lisp lisp)))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp))))
                             ((lisp (lisp (lisp lisp)))
                              (lisp (lisp (lisp (lisp lisp))))))
                            (lisp (lisp (lisp lisp)))))
                          (lisp lisp)))))
                      ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                        (lisp lisp))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       ((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                         ((lisp (lisp (lisp lisp)))
                          ((((lisp (lisp (lisp (lisp lisp))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                (lisp (lisp (lisp (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp (lisp lisp))))))
                                  (lisp (lisp (lisp lisp)))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  ((lisp (lisp (lisp lisp)))
                                   (lisp (lisp (lisp (lisp lisp))))))
                                 (lisp (lisp (lisp lisp)))))
                               (lisp lisp)))))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (lisp (lisp (lisp (lisp lisp))))))
                             (lisp (lisp (lisp lisp)))))))))))
                     (lisp (lisp (lisp lisp)))))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (((lisp (lisp (lisp (lisp lisp))))
                     ((lisp (lisp (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp)))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     ((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp lisp)))))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                              ((lisp (lisp (lisp lisp)))
                               ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
                          ((lisp (lisp (lisp lisp)))
                           (((((lisp (lisp (lisp (lisp lisp))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  (lisp (lisp (lisp (lisp lisp))))))
                                (lisp (lisp (lisp lisp)))))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp)))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      ((lisp (lisp (lisp lisp)))
                                       (lisp (lisp (lisp (lisp lisp))))))
                                     (lisp (lisp (lisp lisp)))))
                                   (lisp lisp)))))
                               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                                 (lisp lisp))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                ((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (lisp lisp))
                                  ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 ((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      ((lisp (lisp (lisp (lisp lisp))))
                                       (lisp lisp))))
                                    (lisp (lisp (lisp lisp))))))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp lisp)))))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp lisp)))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      (lisp lisp))
                                     (lisp lisp)))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp))))))))))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))))))))
                   (lisp (lisp (lisp lisp))))))))))))
          (lisp lisp))))
       (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
        ((lisp (lisp (lisp lisp)))
         (lisp (lisp (lisp lisp))))))))))
  (((lisp (lisp (lisp (lisp lisp))))
    (((lisp (lisp (lisp (lisp lisp))))
      ((lisp (lisp (lisp lisp)))
       (lisp (lisp (lisp (lisp lisp))))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (lisp (lisp (lisp lisp)))))
      (((lisp (lisp (lisp (lisp lisp)))) (lisp 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
nguồn

Đây có phải là một ngôn ngữ thực tế với việc thực hiện? Nếu vậy, bạn có thể vui lòng liên kết với nó?

— Jo King

@JoKing Wikipedia TIO

— Benjamin Urquhart

@BenjaminUrquhart Vâng, Lisp là một ngôn ngữ. Lisplisp tuy nhiên, tôi đã không tìm thấy bằng chứng tồn tại

— Jo King

@JoKing oh tôi hiểu rồi. Có lẽ anh ấy đã đề cập đến điều này?

— Benjamin Urquhart

1

Đây là một dịch giả cho LazyK (Bản thân nó chỉ đơn giản là một triển khai của Công cụ tính toán kết hợp SKI). gist.github.com/SYZYGY-DEV333/d74ca36b9a4c504b25c0a2380203c98d

— -DEV 333

2

Mã máy 8086, 27 byte

Chưa được lắp ráp:

        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

Chuỗi đầu vào trong SI, chiều dài trong CX. Bộ đệm chuỗi đầu ra tại DI.

Kiểm tra đầu ra chương trình IBM PC DOS:

Tải xuống chương trình thử nghiệm R13.COM (PC DOS).

— 640KB
nguồn

1

Haskell - 112 ký tự

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

K, 31

{x^(,/{x!(13_x),13#x}'.Q`A`a)x}

— tmartin
nguồn

{x^a(,/-13 13#\:a:.Q.A)?x}cho 26 byte

— streetster

1

Tcl, 74 ký tự

package require [set c tcl::transform::rot];$c 13 stdin;fcopy stdin stdout

— Julian Kuhn
nguồn

Đầu vào tiêu chuẩn biến đổi ROT-13

Bash, 23 byte

Bash - 5 ký tự

Python 2, 34 byte

Befunge - 7x30 = 210 6x26 = 156 ký tự

Phiên bản cũ

Ruby - 60 57 38 37 ký tự

Kiểm tra

vim, 5 tổ hợp phím

C - 83 79 ký tự

Python (117 byte)

R, 37 byte

Befunge-93, 85 (lưới: 41x3 = 123)

PHP - 103 98 80 ký tự

Delphi, 110

Haskell, 100 ký tự

Con trăn 3 (107)

C: 69 68 ký tự

05AB1E , 13 12 byte

PHP - 41 ký tự

CHIQRSX9 + , 1

C, 136 byte

Javascript, 177 byte

LispLisp (16.636)

Mã máy 8086, 27 byte

Haskell - 112 ký tự

K, 31

Tcl, 74 ký tự