ROT-13 แปลงอินพุตมาตรฐาน

34

ความท้าทาย: เพื่ออ่านอินพุตของความยาวโดยพลการและสร้างROT13ของอินพุต อักขระทั้งหมดที่นอกเหนือจาก AZ ควรคัดลอกไปที่คำต่อคำเอาต์พุตและควรเก็บไว้ในกรณีที่เป็นไปได้

ภาษาใด ๆ ที่สามารถอ่านและเขียนสตรีมมาตรฐานเป็นเกมที่ยุติธรรม

code-golf  cryptography 
— MiffTheFox
แหล่งที่มา
3
ปัญหาไม่ควรเป็นแท็กดังนั้นฉันลบ ROT13 ออกไปเพียงแค่ FYI
— Nick Berardi
2
คุณไม่ได้หมายถึง A-Za-z (นับทั้งตัวใหญ่และตัวเล็ก)?
— Joey Adams
5
@Chris Jester-Young เป็นของหมวดหมู่นี้ที่ wikipedia มันเป็นส่วนหนึ่งของการเข้ารหัสไม่ใช่แค่ยากที่สุด อย่างไรก็ตามฉันไม่ได้ติดตามเว็บไซต์นี้อีกต่อไป ชุมชนทำให้ฉันผิดหวัง ขอโทษ GL HF
— Nakilon
17
บอกxor ไม่ได้เข้ารหัสเป็นเหมือนว่าA + B ไม่ได้คณิตศาสตร์
— Nakilon
3
แท็กถูกใช้เพื่อจัดหมวดหมู่คำถามและช่วยค้นหาคำถามที่คล้ายกัน เข้ารหัสแท็ก (จากภาษากรีก kryptos "ซ่อนความลับ" และ GRAPHEIN "เขียน") โดยเฉพาะอย่างยิ่งที่เป็นปัญหาการเข้ารหัสและถอดรหัส การเข้ารหัสและถอดรหัสทั้งหมดไม่เพียง แต่จะปลอดภัยสำหรับแอพพลิเคชั่นที่ทันสมัย
— Angs

คำตอบ:

25

Bash, 23 ไบต์

คำตอบที่ยอมรับได้ 23 อักขระ:

tr A-Za-z N-ZA-Mn-za-m
— Chris Jester-Young
แหล่งที่มา
1
ฉันไม่สามารถทุบตีได้ในขณะนี้ แต่ฉันคิดว่านี่น่าจะใช้ได้: tr A-za-m N-ZA-z(16 ตัวอักษร)
— Nabb
2
@Nabb: ดีใจที่ได้พบคุณ GolfScript-meister! : -DI คิดว่าวิธีการแก้ปัญหาของคุณที่นี่จะผิดเงื่อนไขที่ "ตัวละครทั้งหมดนอกเหนือจาก AZ ควรคัดลอกไปยังคำต่อคำออก"
— Chris Jester-Young
@Chris: ใช่ดูเหมือนว่าคุณพูดถูก
— Nabb
@Nabb: ไม่สำหรับฉันมันดูเหมือนว่าเขาผิด หรือคุณอาจแสดงตัวอย่าง
— ผู้ใช้ที่ไม่รู้จัก
2
@ ผู้ใช้ที่ไม่รู้จัก: พิมพ์ใน[\\]^_`อินพุต มันจะกลับมาNOPQRSมากกว่า[\\]^_`อย่างน้อยในเวอร์ชันของtrฉัน (ผู้ที่มีหกตัวละครใน ASCII ที่อยู่ระหว่างZและaเห็นได้ชัดว่าตัวละครอื่น ๆ ทั้งหมดจะทำงานอย่างถูกต้อง..)
— คริสเจสเตอร์หนุ่ม
20

Bash - 5 ตัวอักษร

rot13

 

— gnibbler
แหล่งที่มา
18
สอง downvotes จนถึงขณะนี้ (ที่ไม่มีความคิดเห็น) แต่ไม่มี downvotes สำหรับคำถาม ฉันคิดว่านั่นหมายความว่าไม่เป็นไรที่จะถาม codegolfs เล็กน้อย แต่ไม่ให้คำตอบเล็กน้อย โปรด codegolfs ยากขึ้น !
— gnibbler
8
เวอร์ชันทุบตีใด? ฉันไม่มี rot13 ในตัว bash --version GNU bash, Version 4.0.33(1)-release (i486-pc-linux-gnu)
— ผู้ใช้ไม่รู้จัก
12
ฉันได้ส่งสิ่งนี้เป็นrot13 - 0 chars... ;)
— boothby
2
'tis coreutils เพื่อนของฉันไม่ใช่ Bash
— TheDoctor
3
เอ่อ ... ไม่ ทุบตีของฉัน (อูบุนตู 13.10) บอกว่า "ไม่พบคำสั่งคุณสามารถติดตั้งโปรแกรมนี้ได้โดยsudo apt-get install bsdgames"
17

Python 2, 34 ไบต์

print raw_input().encode('rot13')
— ฮวน
แหล่งที่มา
1
-1 ฉันคิดว่ามันเป็นการโกงว่าคุณกำลังใช้ห้องสมุดในตัว
— เกล็นเนลสัน
16
ฉันใช้มันในทุกรหัสกอล์ฟที่ฉันเข้าร่วม ... นอกจากนี้หากใช้ lib มาตรฐานของ python คือการโกงการใช้ tr ไม่ได้อย่างไร
— Juan
3
@Anon ไม่ว่าในกรณีใดมันเป็น anwser ที่คุณไม่สนใจ .. มันไม่ได้เป็นเป้าหมายไม่มีกฎใด ๆ ที่กำหนดโดย OP หรือชุมชน แน่นอนว่าของฉันอาจไม่ใช่โซลูชันที่ชนะรางวัลเช่นเดียวกับที่ใช้ TR ที่เตะตูด แต่มันไม่ใช่เรื่องตลกฉันใช้ประโยชน์จากพลังของหลามเพื่อลดจำนวนเช่นเดียวกับที่คนอื่นทำ
— Juan
2
@ Glenn: ในทางตรงกันข้ามฉันไม่เคยเห็นสิ่งที่รหัสกอล์ฟที่พูดอย่างนั้น codegolf.com, golf.shinh.org หรือ SPOJ SHORTEN
— hallvabo
9
@Glenn ฉันคิดว่าฟังก์ชั่นห้องสมุดเป็นเกมที่ยุติธรรม มันขึ้นอยู่กับคำถามกอล์ฟที่จะน่าสนใจพอที่จะไม่อยู่ในห้องสมุดของใครหรือแยกออกเป็นพิเศษ
— gnibbler
15

Befunge - 7x30 = 210 6x26 = 156 ตัวอักษร

เวอร์ชั่นสตรีมมิ่งใหม่ที่รองรับตัวพิมพ์ใหญ่และตัวพิมพ์เล็กและควรรองรับอินพุตไม่ จำกัด

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

รุ่นเก่า

สิ่งนี้จะเก็บค่าไว้ในซอร์สโค้ดของมันเอง แสดงให้เห็นว่ามันน่ากลัวเพียงใดในการลองและส่งออกค่าที่เก็บไว้ในลำดับเดียวกันกับที่คุณได้รับ รองรับอักขระตัวพิมพ์เล็กเท่านั้น

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

ฉันไม่แน่ใจว่าสิ่งนี้มีข้อ จำกัด เพียงใดโดยใช้http://www.quirkster.com/iano/js/befunge.htmlเป็นล่ามที่ดูเหมือนจะทำลายด้วยอินพุตขนาดใหญ่

— Nemo157
แหล่งที่มา
คุณสามารถลบช่องว่างที่ท้ายบรรทัด
— Zacharý
10

Ruby - 60 57 38 37 ตัวอักษร

แก้ไข: และเพิ่งรู้ว่าสายทับทิมมีtrวิธี

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

ทดสอบ

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

ให้:

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
แหล่งที่มา
คุณไม่ต้องการช่องว่างหลังจากputsนั้นและ 'Az' เป็นทางลัดสำหรับ 'A-Za-z'
— Ventero
1
@Ventro: ขอบคุณหลังจากบิตของการทดสอบนั้นดูเหมือนว่า'A-z'เป็นจริง'A-Z[\]^_a-z' , damn ascii having characters between Z` aและ
— Nemo157
1
หลักเดียวกัน แต่ 35 puts gets.tr'A-Za-z','N-ZA-Mn-za-m'ตัวอักษร:
— Michael Kohl
@Michael: ยกเว้นgetsส่งคืนบรรทัดแรกโดยใช้ $ <อ่านเพื่ออ่านจนกว่า EOF คำถามไม่ได้พูดอะไรเกี่ยวกับว่าอินพุตสามารถมีบรรทัดใหม่หรือไม่ดังนั้นฉันจึงผิดพลาดไปข้างๆข้อควรระวัง
— Nemo157
ยุติธรรมพอ แต่เนื่องจากข้อกำหนดเฉพาะของการฝึกพูดถึง "ความยาวตามอำเภอใจ" แต่ไม่ได้พูดอะไรเกี่ยวกับการขึ้นบรรทัดใหม่ฉันจึงค่อนข้างผิดพลาดในด้านความกะทัดรัดใน codegolf ;-)
— Michael Kohl
10

เป็นกลุ่ม, 5 การกดแป้น

สมมติว่าโหมดปกติและข้อความนั้นถูกเขียนไปแล้วในบัฟเฟอร์:

ggg?G

หรือทิ้งการประชุมของ vimgolf:

g?GZZ

คุณสามารถเรียกมันเป็นคำสั่งเทอร์มินัลเช่นนี้:

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

ฉันเดาว่าหลังจะนับเป็น "โปรแกรม" ของ 8 ตัวอักษร ( norm g?G)

— daniero
แหล่งที่มา
norm g?Gสั้นสำหรับnormal g?Gที่ทำให้ 8 ตัวอักษร
— Patrick Oscity
ฉันคิดว่าคุณสามารถสันนิษฐานได้อย่างปลอดภัยว่าจะเริ่มต้นจากบรรทัดที่ 1 ดังนั้นสิ่งแรกที่ggจะถูกปล่อยออกไป ฉันจะบอกว่า 3 การกดแป้นเมื่อเปิดไฟล์
— Patrick Oscity
1
หากเราใช้ระเบียบของ vimgolf (คุณเริ่มใน vanilla vim ที่เพิ่งเปิดไฟล์ แต่ต้องการบันทึกและออก) เราก็รับ 5 ( g?GZZ)
— FireFly
7

C - 83 79 ตัวอักษร

main(c,b){while((c=getchar())>=0)b=c&96,putchar(isalpha(c)?b+1+(c-b+12)%26: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
แหล่งที่มา
1
คุณรวมส่วนหัวที่คุณรวมไว้ในการนับของคุณหรือไม่
— JPvdMerwe
@JPvdMerwe: ฉันไม่ได้รวมส่วนหัวไว้ในเวอร์ชัน golfed และฉันไม่ต้องการ
— Joey Adams
คุณสามารถใช้ตัวดำเนินการ coma ก่อน putchar เพื่อลบวงเล็บปีกกา
— Alexandru
คุณช่วยอธิบาย main (c, b) ได้ไหม นี่เป็นครั้งแรกที่ฉันเห็นสิ่งนี้
— Alexandru
2
@Alexandru คอมไพเลอร์ C ส่วนใหญ่สนับสนุนหลักด้วยพารามิเตอร์ใด ๆ นอกจากนี้มาตรฐาน C ดั้งเดิมกำหนดว่าข้อโต้แย้งที่ไม่มีประเภทเป็น int ดังนั้นคุณจะต้องประกาศ int โดยไม่ต้องเขียน int จริง
— Juan
7

Python (117 ไบต์)

นี่เป็นรุ่นหลามที่หลีกเลี่ยง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
แหล่งที่มา
raw_input ส่งคืนหนึ่งบรรทัดไม่ใช่อินพุตทั้งหมด
— Alexandru
คุณต้องและการใช้งานimport sys sys.stdin.read()
— อเล็กซานด
@Alexandru: จะทำ
— JPvdMerwe
-2 ไบต์หากคุณกำจัดรายการที่[]จะสร้างกำเนิด: tio.run/…
— connectyourcharger
7

tr///วิธีการแก้ปัญหาใน Perl (39 ตัวอักษร) สามารถลบ boilerplate ได้ด้วย-p:

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

การใช้-p(23 ตัวอักษรรวมถึงสวิตช์พิเศษ):

perl -pe'y/a-zA-Z/n-za-mN-ZA-M/'
— ไม่ช้า
แหล่งที่มา
เพิ่ม 1 ถ่านสำหรับ p แต่โปรดลบแผ่นสำเร็จรูป!
— JB
7

R, 37 ไบต์

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

example("chartr")เรียกใช้ตัวอย่างสำหรับchartrซึ่งรวมถึงrotฟังก์ชั่นซึ่งเป็นROT13ค่าเริ่มต้น ....

— mnel
แหล่งที่มา
5

DC ( 111 108 สำหรับ dc เอง)

ตกลงที่นี่มันอยู่ใน (ส่วนใหญ่) dc และบางส่วนและความมหัศจรรย์และความมหัศจรรย์ที่จะได้รับมันในรูปแบบที่เหมาะสมสำหรับรหัส หากคุณไม่นับสิ่งที่อินพุต ( echo -n MESSAGE |) คือ 160 ไบต์:

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'

ในฐานะที่เป็นจุดสนใจโปรแกรม dcนั้นมีความยาว108 ไบต์ซึ่งสั้นกว่าเวอร์ชันไพ ธ อนที่ไม่ใช่ไลบรารี่ มันยังรักษากรณีและเครื่องหมายวรรคตอนและเต้นจาวาสคริปต์ในการส่งข้างต้น! ถ้าฉันเท่านั้นที่สามารถแยกวิเคราะห์ผลลัพธ์ของ od หรือดีกว่ายังแทนที่มันทั้งหมด

แก้ไข: มันเป็นที่น่าสังเกตว่าคำถามไม่ได้ระบุบรรทัดใหม่ต่อท้าย10Pซึ่งช่วยให้ฉันสามไบต์ต่อไป

แก้ไข 2: ไม่มีข้อมูลจำเพาะสำหรับรูปแบบของอินพุตดังนั้นฉันจึงถือว่ามันใช้งานได้สะดวกสำหรับโปรแกรมของฉัน: P

— Hiato
แหล่งที่มา
5

Befunge-93, 85 (ตาราง: 41x3 = 123)

นี่เป็นคำถามโบราณ แต่ฉันคิดว่าฉันจะรื้อฟื้นมันเพื่อโพสต์คำตอบ Befunge ที่ดีกว่าเล็กน้อย

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

คุณสามารถทดสอบได้ที่นี่ ป้อนอักขระครั้งละหนึ่งตัว มันสิ้นสุดลงเมื่อป้อน.ตัวอักษร (คุณสามารถเปลี่ยนได้โดยแก้ไข"."ทางด้านขวาของแถวที่สอง) ใช้งานได้กับตัวพิมพ์ใหญ่และตัวพิมพ์เล็กเช่นเดียวกับเครื่องหมายวรรคตอนและไม่ จำกัด อินพุต

ฉันไม่คาดหวังว่าสิ่งนี้จะได้รับ upvotes หรืออะไรมากมาย แต่ฉันแค่ต้องการแสดงให้เห็นว่า Befunge ยอดเยี่ยมจริงๆแล้วคุณสามารถทำได้ดีกว่าคำตอบอื่น ๆ เล็กน้อย

ฉันอาจทำให้สั้นลงใน Befunge-98

— Kasran
แหล่งที่มา
คุณสามารถเพิ่มตัวอย่างของฉันจากที่นี่เพื่อมีล่ามแบบอินไลน์หากคุณต้องการ :)
— Ingo Bürk
โอ้ฉันยังไม่ได้ตรวจสอบตัวอย่างเลย ฉันจะดูสิขอบคุณ!
— Kasran
วิธีนี้ใช้ไม่ได้หากมีช่องว่างในอินพุต มันจะเข้าสู่วงวนไม่สิ้นสุดในลำดับ>$! _เนื่องจากคุณมีศูนย์สองตัวบนสแต็ก ณ จุดนั้นเมื่อคุณคาดหวังว่าค่าที่ไม่เป็นศูนย์
— James Holderness
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
แหล่งที่มา
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.บันทึกตัวละครตัวหนึ่ง :)
— Wouter van Nifterick
@Wouter van Nifterick: จุดที่ดี! ฉันจะอัปเดตตามนั้น
— PatrickvL
3

Java 251 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);}}}
— ไคลด์โลโบ
แหล่งที่มา
3

Python 3 (107)

ตกลงฉันสัญญาว่าจะหยุดตอบคำถามนี้ในตอนนี้ แต่ฉันรู้สึกว่าถูกบังคับให้เอาชนะคำตอบ DC ใน Python นี่อาจสะท้อนถึงฉันไม่ดีในฐานะบุคคล :)

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 ตัวอักษร

เอาล่ะฉันรู้ว่ากระทู้นี้ตายไปนานแล้ว แต่ฉันก็ทนไม่ได้ (ยาว) C-solution ที่ไม่แม้แต่จะรวบรวมบน Clang (แต่ใช้กับ GCC)

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

มันอาจจะยังเกือบจะบีบได้ แน่นอนว่ามันสามารถบีบได้ และไม่เพียง แต่สามารถบีบได้ แต่เป็นไปได้ที่จะทำให้เกิดการเรียกซ้ำ

— Fors
แหล่งที่มา
3

05AB1E , 13 12 ไบต์

บันทึกเป็นไบต์ด้วยrobbie0630

ADu)øJD2äRJ‡

ลองออนไลน์!

คำอธิบาย

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
แหล่งที่มา
ฉันวิ่งผ่านสิ่งนี้ด้วย--debugและดูเหมือนว่า˜จะไม่มี op ในกรณีนี้และสามารถตัดออกได้
— ร็อบบี้
@ robbie0630: จริง ไม่รู้เลยว่าทำไมฉันถึงได้เป็นเช่นนั้นขอบคุณ :)
— 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))}))

วิธีการแก้ปัญหานี้แก้ปัญหาโดยการเพิ่ม 13 ตัวอักษรรหัสถ้าตัวละครที่มีปัญหาอยู่ในช่วงครึ่งแรกของตัวอักษรหรือลบ 13 ถ้ามันอยู่ในช่วงครึ่งหลัง

— Casey Chu
แหล่งที่มา
คุณสามารถบันทึก7ตัวละครโดยการแทนที่ด้วย+(c.toLowerCase()<'n'?13:-13)) -13+26*/[a-m]/i.test(c)
— จาค็อบ
2

CHIQRSX9 + , 1

R

คุณเพียงแค่ต้องใช้เครื่องมือที่เหมาะสมสำหรับปัญหา
CHIQRSX9 + Cเป็นทัวริงสมบูรณ์และสามารถอ่านและเขียนจากช่องทางที่มีมาตรฐาน

— โยฮันน์คุห์น
แหล่งที่มา
5
@ nyuszika7h ภาษาถูกประดิษฐ์ขึ้นก่อนที่คำถามนี้จะถูกเขียนดังนั้นจึงถูกต้อง
— Johannes Kuhn
1
มันยังคงเป็นหนึ่งในสิ่งที่มันถูกคิดค้นขึ้นมา ดูเหมือนว่าจะนอกใจฉัน
— nyuszika7h
7
@ nyuszika7h และ golfscript ถูกคิดค้นเพื่อเอาชนะความท้าทายในการเล่นกอล์ฟ คุณคิดว่านั่นเป็นการโกงด้วยหรือไม่
— Johannes Kuhn
2
@Mego มันไม่ค่อยยุติธรรมที่จะใช้มาตรฐานเหล่านี้ที่นี่เมื่อพวกเขาเขียนหนึ่งปีหลังจากคำตอบนี้
— Doorknob
2
— ชำเลือง
2

C, 136 ไบต์

ฉันไม่เคยรู้สึกเหมือนวิธีแก้ไขปัญหาใด ๆ ของฉันดีพอที่จะโพสต์ที่นี่ แต่ทำเพื่อความสนุกและคิดว่ามันจะเป็นประตูยาเสพติดของฉันในการเขียนโค้ดกอล์ฟ

#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
แหล่งที่มา
4
ยินดีต้อนรับสู่การเขียนโปรแกรมปริศนาและการแลกเปลี่ยนรหัสกองกอล์ฟ คำตอบแรกที่ดี และสำหรับบันทึกเราทุกคนรู้สึกอย่างนั้นบางครั้งเพียงรู้ว่าสิ่งที่คุณสร้างคือ "ดีพอ" ที่ไหนสักแห่ง
— GamrCorps
2
ทุกอย่างที่นี่บน PPCG เป็นเพียงเพื่อความสนุกสนาน (หรือจุดอินเทอร์เน็ตในจินตนาการ) - โปรดอย่ารู้สึกว่างานที่คุณทำขึ้นมาเพื่อแก้ปัญหานั้นไม่ได้ "ดีพอ"
— cat
ขอบคุณสำหรับการสนับสนุน ฉันคิดว่าการโพสต์สิ่งที่เป็นทั้งหมดที่ฉันต้องได้รับหัวของฉันในเกียร์ ฉันจะลองใช้ความท้าทายเหล่านี้เพิ่มเติมในไม่ช้า
— Tormyst
2

Javascript, 177 ไบต์

นี่ถือว่ามีสองฟังก์ชั่นพิมพ์และ 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
แหล่งที่มา
2

LispLisp (16,636)

ฉันขอโทษ.

((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
  (lisp lisp))
 (((lisp (lisp (lisp (lisp lisp))))
   ((lisp (lisp (lisp lisp)))
    ((lisp (lisp (lisp (lisp lisp))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (((lisp (lisp (lisp (lisp lisp))))
          (((lisp (lisp (lisp (lisp lisp))))
            ((lisp (lisp (lisp lisp)))
             (lisp (lisp (lisp (lisp lisp))))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (lisp (lisp (lisp lisp)))))
            (((lisp (lisp (lisp (lisp lisp))))
              ((lisp (lisp (lisp lisp)))
               (lisp (lisp (lisp (lisp lisp))))))
             (((lisp (lisp (lisp (lisp lisp))))
               ((lisp (lisp (lisp lisp)))
                ((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))))
              (lisp (lisp (lisp lisp))))))))
         ((lisp (lisp (lisp lisp)))
          (lisp (lisp (lisp lisp)))))))
      (((lisp (lisp (lisp (lisp lisp))))
        ((lisp (lisp (lisp lisp)))
         (((lisp (lisp (lisp (lisp lisp))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (lisp (lisp (lisp lisp)))))))
            (((lisp (lisp (lisp (lisp lisp))))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 ((lisp (lisp (lisp lisp)))
                  ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
             ((lisp (lisp (lisp lisp)))
              (((((lisp (lisp (lisp (lisp lisp))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     (lisp (lisp (lisp (lisp lisp))))))
                   (lisp (lisp (lisp lisp)))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp (lisp lisp))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (lisp (lisp (lisp (lisp lisp))))))
                      (lisp (lisp (lisp lisp))))))
                   (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                    (lisp lisp)))
                  (((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (lisp lisp))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                     ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                 (lisp (lisp (lisp lisp)))))
               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 (((lisp (lisp (lisp (lisp lisp))))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp))
                     ((((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         ((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                           ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                       (lisp (lisp (lisp lisp))))))))
                  (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                         (lisp (lisp (lisp lisp))))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       (lisp lisp))))))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         (lisp (lisp (lisp (lisp lisp))))))
                       (lisp (lisp (lisp lisp)))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp))))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp (lisp lisp))))))
                           (lisp (lisp (lisp lisp)))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp))))
                             ((lisp (lisp (lisp lisp)))
                              (lisp (lisp (lisp (lisp lisp))))))
                            (lisp (lisp (lisp lisp)))))
                          (lisp lisp)))))
                      ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                        (lisp lisp))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       ((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                         ((lisp (lisp (lisp lisp)))
                          ((((lisp (lisp (lisp (lisp lisp))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                (lisp (lisp (lisp (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp (lisp lisp))))))
                                  (lisp (lisp (lisp lisp)))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  ((lisp (lisp (lisp lisp)))
                                   (lisp (lisp (lisp (lisp lisp))))))
                                 (lisp (lisp (lisp lisp)))))
                               (lisp lisp)))))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (lisp (lisp (lisp (lisp lisp))))))
                             (lisp (lisp (lisp lisp)))))))))))
                     (lisp (lisp (lisp lisp)))))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (((lisp (lisp (lisp (lisp lisp))))
                     ((lisp (lisp (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp)))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     ((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp lisp)))))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                              ((lisp (lisp (lisp lisp)))
                               ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
                          ((lisp (lisp (lisp lisp)))
                           (((((lisp (lisp (lisp (lisp lisp))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  (lisp (lisp (lisp (lisp lisp))))))
                                (lisp (lisp (lisp lisp)))))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp)))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      ((lisp (lisp (lisp lisp)))
                                       (lisp (lisp (lisp (lisp lisp))))))
                                     (lisp (lisp (lisp lisp)))))
                                   (lisp lisp)))))
                               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                                 (lisp lisp))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                ((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (lisp lisp))
                                  ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 ((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      ((lisp (lisp (lisp (lisp lisp))))
                                       (lisp lisp))))
                                    (lisp (lisp (lisp lisp))))))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp lisp)))))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp lisp)))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      (lisp lisp))
                                     (lisp lisp)))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp))))))))))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))))))))
                   (lisp (lisp (lisp lisp))))))))))))
          (lisp lisp))))
       (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
        ((lisp (lisp (lisp lisp)))
         (lisp (lisp (lisp lisp))))))))))
  (((lisp (lisp (lisp (lisp lisp))))
    (((lisp (lisp (lisp (lisp lisp))))
      ((lisp (lisp (lisp lisp)))
       (lisp (lisp (lisp (lisp lisp))))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (lisp (lisp (lisp lisp)))))
      (((lisp (lisp (lisp (lisp lisp)))) (lisp 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
แหล่งที่มา
นี่เป็นภาษาจริงที่มีการนำไปปฏิบัติหรือไม่? ถ้าเป็นเช่นนั้นคุณช่วยลิงค์ไปได้ไหม?
— Jo King
@JoKing Wikipedia TIO
— Benjamin Urquhart
@BenjaminUrquhart ใช่ Lisp เป็นภาษา ลิสบอน แต่ฉันไม่พบหลักฐาน
— โจคิง
— Benjamin Urquhart
1
นี่คือนักแปลของ LazyK (ตัวมันเองเป็นเพียงการนำไปใช้กับแคลคูลัส SKI Combinator) gist.github.com/SYZYGY-DEV333/d74ca36b9a4c504b25c0a2380203c98d
— SYZYGY-DEV 333
2

รหัสเครื่อง 8086, 27 ไบต์

แต่อย่างใด:

        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

สายป้อนในความยาวในSI บัฟเฟอร์สตริงเอาท์พุทที่CXDI

ทดสอบเอาต์พุตโปรแกรม IBM PC DOS:

ป้อนคำอธิบายรูปภาพที่นี่

ดาวน์โหลดโปรแกรมทดสอบR13.COM (PC DOS)

— 640KB
แหล่งที่มา
1

Haskell - 112 ตัวอักษร

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)
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.