34

चुनौती: मनमाने ढंग से लंबाई के इनपुट को पढ़ने और इनपुट के ROT13 का उत्पादन करने के लिए। AZ के अलावा सभी वर्णों को आउटपुट वर्बेटिम में कॉपी किया जाना चाहिए, और यदि संभव हो तो मामले को संरक्षित किया जाना चाहिए।

मानक धाराओं को पढ़ने और लिखने वाली कोई भी भाषा निष्पक्ष खेल है।

code-golf cryptography

— MiffTheFox
स्रोत

3

समस्या एक टैग नहीं होनी चाहिए, इसलिए मैंने ROT13 को हटा दिया, सिर्फ एक FYI करें

— निक बरार्डी

2

क्या आपका मतलब ए-ज़-ज़ (ऊपरी और निचले-दोनों मामलों की गणना करने के लिए) नहीं है?

— जोए एडम्स

5

@ क्रिस जस्टर-यंग, यह विकिपीडिया पर इसी श्रेणी का है। यह क्रिप्टोग्राफी का हिस्सा है, न कि सबसे कठिन। वैसे भी, मैं अब इस साइट का अनुसरण नहीं कर रहा हूं। समुदाय ने मुझे अलग कर दिया। माफ़ कीजिये। जीएल एचएफ।

— Nakilon

17

Xor कहना एन्क्रिप्शन नहीं है, ऐसा कहना है जैसे a + b गणित नहीं है ।

— Nakilon

3

टैग का उपयोग प्रश्नों को वर्गीकृत करने और समान प्रश्नों को खोजने में मदद करने के लिए किया जाता है। क्रिप्टोग्राफी टैग (ग्रीक Kryptos से, "छिपा हुआ, गुप्त", और graphein, "लेखन") विशेष रूप से एन्क्रिप्शन और डिक्रिप्शन समस्याओं के लिए है। सभी एन्क्रिप्शन और डिक्रिप्शन, न केवल उन जो आधुनिक अनुप्रयोगों के लिए सुरक्षित हैं।

— आंग।

25

बैश, 23 बाइट्स

विहित 23-वर्ण उत्तर:

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

— क्रिस जस्टर-यंग
स्रोत

1

मैं इस समय कोसने के लिए पहुँच के बिना हूँ, लेकिन मुझे लगता है कि यह काम करना चाहिए: tr A-za-m N-ZA-z(16 वर्ण)

— नब्ब

2

@ नब: आपको देखकर अच्छा लगा, गोल्फस्क्रिप्ट-मिस्टर! : -DI को लगता है कि आपका समाधान यहाँ इस शर्त को तोड़ देगा कि "AZ के अलावा सभी वर्णों को आउटपुट वर्बेटिम में कॉपी किया जाना चाहिए"।

— क्रिस जस्टर-यंग

@ क्रिस: हाँ, लगता है जैसे तुम सही हो।

— नब

@ नब: नहीं, मेरे लिए ऐसा लगता है जैसे वह गलत है। या आप एक उदाहरण दिखा सकते हैं?

— उपयोगकर्ता अज्ञात

2

@user अज्ञात: [\\]^_`इनपुट में टाइप करें । यह मेरे NOPQRSबजाय [\\]^_`कम से कम संस्करण में वापस आ जाएगा tr। (एएससीआईआई में वे छह पात्र हैं जो बीच Z- बीच में झूठ बोलते हैं a। जाहिर है, अन्य सभी पात्र सही तरीके से काम करेंगे।)

— क्रिस जस्टर-यंग

20

बैश - 5 वर्ण

rot13

— gnibbler
स्रोत

18

दो डाउनवोट अब तक (कोई टिप्पणी नहीं), लेकिन सवाल के लिए कोई डाउनवोट नहीं। मुझे लगता है कि इसका मतलब है कि तुच्छ कोडगुल्लों से पूछना ठीक है लेकिन तुच्छ उत्तर नहीं देना है। कठोर कोडगुल्लों कृपया!

— gnibbler

8

कौन सा बैश-संस्करण? मेरे पास बिल्ड-इन रोट 13 नहीं है। bash --version GNU bash, Version 4.0.33(1)-release (i486-pc-linux-gnu)

— उपयोगकर्ता अज्ञात

12

मैंने इसे rot13 - 0 chars...;) के रूप में प्रस्तुत किया है

— बूथ

2

'टिस ने मेरे दोस्त को बैश किया, न कि बैश

— द डॉकटर

3

erm ... नहीं। मेरा बैश (उबंटू 13.10) कहता है "कमांड नहीं मिला, आप इस प्रोग्राम को स्थापित कर सकते हैं sudo apt-get install bsdgames"

17

पायथन 2, 34 बाइट्स

print raw_input().encode('rot13')

— जुआन
स्रोत

1

-1 मुझे लगता है कि यह धोखा है कि आप एक निर्मित पुस्तकालय का उपयोग कर रहे हैं।

— ग्लेन नेल्सन

16

मैंने उन्हें हर उस कोड गोल्फ में इस्तेमाल किया है, जिसमें मैंने भाग लिया था ... इसके अलावा अगर अजगर के मानक का इस्तेमाल धोखा दे रहा है, तो ट्राय नहीं कर रहा है?

— जुआन

3

@ किसी भी मामले में, यह एक ऐसा अनाउंसर है जिसे आप अनदेखा करते हैं .. यह लक्ष्य से दूर नहीं है, न ही ओपी द्वारा और न ही समुदाय द्वारा निर्धारित कोई नियम है। यकीन है, शायद मेरा एक पुरस्कार विजेता समाधान नहीं है, जैसे कि ट्रिक्स का उपयोग करके गधा। लेकिन यह कोई मजाक नहीं है, मैं गिनती कम करने के लिए अजगर की शक्ति का लाभ उठा रहा हूं, ठीक वैसे ही जैसे कोई और करेगा।

— जुआन

2

@ ग्लेन: इसके विपरीत, मैंने कभी भी एक कोड-गोल्फ चीज़ नहीं देखी है जो ऐसा कहती है। न ही codegolf.com, golf.shinh.org या SPOJ SHORTEN करें।

— १०:३६ पर हॉलवबो

9

@ मुझे लगता है, पुस्तकालय के कार्य निष्पक्ष खेल हैं। यह किसी भी पुस्तकालय में नहीं होना या विशेष रूप से बाहर करने के लिए दिलचस्प होना गोल्फ प्रश्न पर निर्भर है।

— जिब्बलर २ g

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
स्रोत

आप लाइनों के अंत में व्हाट्सएप को हटा सकते हैं।

— 18

10

रूबी - 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[\]^_एक z-z ' , damn ascii having characters between Z` और है a।

— निमो 157

1

अनिवार्य रूप से समान लेकिन 35 वर्ण puts gets.tr'A-Za-z','N-ZA-Mn-za-m':।

— माइकल कोहल

@ मिचेल: getsकेवल $ <का उपयोग करके केवल पहली पंक्ति को लौटाता है। EOF तक रीड पढ़ता है। प्रश्न इस बारे में कुछ नहीं कहता है कि क्या इनपुट में नई लाइनें हो सकती हैं इसलिए मैंने सावधानी के साथ इसे मिटा दिया।

— निमो 157

पर्याप्त रूप से उचित है, लेकिन चूंकि व्यायाम विनिर्देश में "मनमाना लंबाई" का उल्लेख किया गया है, लेकिन नई कथनों के बारे में कुछ भी नहीं कहा गया है, मैं कोडगॉल्फ में संक्षिप्तता के पक्ष में नहीं; ;-)

— माइकल कोहल

10

विम, 5 कीस्ट्रोक्स

सामान्य मोड और मान लें कि पाठ पहले से ही बफर में लिखा गया है:

ggg?G

या, विमगॉल्फ के सम्मेलनों को गिराना:

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 वर्ण बनाता है।

— पैट्रिक ऑसिटी

मुझे लगता है कि आप सुरक्षित रूप से लाइन 1 पर शुरू करने के लिए मान सकते हैं, इसलिए पहले ggको छोड़ा जा सकता है। मैं कहूंगा कि जब फ़ाइल खुली हो तो 3 कीस्ट्रोक।

— पैट्रिक ऑसिटी

1

यदि हम विमगॉल्फ के सम्मेलनों का उपयोग करते हैं (आप एक वेनिला विम में शुरू करते हैं, जिसमें केवल फ़ाइल खोली जाती है, लेकिन हमें सहेजने और छोड़ने की आवश्यकता होती है) हमें भी 5 ( g?GZZ) मिलता है ।

— फायरफली

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

— जॉय एडम्स
स्रोत

1

क्या आप उन शीर्षकों में शामिल हैं जिन्हें आप अपनी गिनती में शामिल करते हैं?

— JPvdMerwe

@JPvdMerwe: मैंने किसी भी हेडर को गोल्फ संस्करण में शामिल नहीं किया है, और न ही मुझे इसकी आवश्यकता है।

— जोए एडम्स

आप एक जोड़ी ब्रेसिज़ को हटाने के लिए पुचर से पहले कोमा ऑपरेटर का उपयोग कर सकते हैं।

— अलेक्जेंड्रू

क्या आप मुख्य (c, b) समझा सकते हैं? यह पहली बार है जब मैंने यह देखा है।

— अलेक्जेंड्रू

2

@Alexandru अधिकांश सी संकलक किसी भी पैरामीटर के साथ मुख्य का समर्थन करते हैं। साथ ही, मूल C मानक यह परिभाषित करता है कि बिना किसी प्रकार के एक तर्क एक int है। इस प्रकार आप वास्तव में int लिखने के बिना ints घोषित करने के लिए मिलता है।

— जुआन

7

पायथन (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 सभी इनपुट नहीं एक पंक्ति देता है।

— अलेक्जेंड्रू

आपको जरूरत है import sysऔर उपयोग की sys.stdin.read()।

— अलेक्जेंड्रू

— अलेक्सांद्रु

-2 बाइट्स यदि आप []सूची को जनरेटर बनाने के लिए खत्म कर देते हैं: tio.run/…

— connectyourcharger

7

tr///पर्ल में समाधान (39 अक्षर), बॉयलरप्लेट को हटाया जा सकता है -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/'

— Anon।
स्रोत

पी के लिए 1 चार जोड़ें, लेकिन कृपया बॉयलरप्लेट हटा दें!

— JB

7

आर, 37 बाइट्स

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

example("chartr")के लिए उदाहरण चलाता है chartr, जिसमें rotफ़ंक्शन शामिल है , जो ROT13डिफ़ॉल्ट रूप से है ...।

— mnel
स्रोत

5

डीसी ( ~~111~~ 108 डीसी के लिए)

ठीक है, यहाँ यह (ज्यादातर) डीसी और कुछ सेड और ओड मैजिक में है ताकि इसे कोड के लिए सही प्रारूप में लाया जा सके। यदि आप इनपुट चीज़ की गणना नहीं करते हैं ( 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'

रुचि के बिंदु के रूप में, डीसी प्रोग्राम स्वयं में केवल 108 बाइट्स है , जो गैर-लाइब्रेरी पायथन संस्करण की तुलना में छोटा है। यह मामला और विराम चिह्न को भी संरक्षित करता है, और उपरोक्त सबमिशन में जावास्क्रिप्ट धड़कता है! यदि केवल मैं ही od के आउटपुट को बेहतर तरीके से पार्स कर सकता हूं, या बेहतर अभी तक पूरी तरह से प्रतिस्थापित कर सकता हूं।

संपादित करें: यह ध्यान देने योग्य है कि प्रश्न एक नई नई रेखा को इंगित नहीं करता है 10Pजो मुझे तीन और बाइट्स बचाती है।

संपादित 2: इनपुट के प्रारूप के लिए कोई विनिर्देश नहीं है, इसलिए मुझे लगता है कि यह मेरे कार्यक्रम के लिए सुविधाजनक है: पी

— Hiato
स्रोत

5

Befunge-93, 85 (ग्रिड: 41x3 = 123)

यह एक प्राचीन प्रश्न है, लेकिन मैंने सोचा कि मैं इसे थोड़े अच्छे अच्छे Befunge उत्तर पोस्ट करने के लिए पुनर्जीवित करूंगा।

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

आप इसे यहाँ परीक्षण कर सकते हैं । एक बार में एक ही वर्ण दर्ज करें; यह एक .चरित्र में प्रवेश करने पर समाप्त होता है (आप "."दूसरी पंक्ति के दाईं ओर के पास को संशोधित करके बदल सकते हैं )। ऊपरी और निचले मामले के साथ-साथ विराम चिह्न, और इनपुट की कोई सीमा नहीं के साथ काम करता है।

मुझे उम्मीद नहीं है कि यह एक टन तक या कुछ भी प्राप्त कर सकता है, लेकिन मैं बस यह प्रदर्शित करना चाहता था कि ~~वास्तव में बेफुज कितना भयानक है~~ कि आप अन्य उत्तर की तुलना में थोड़ा बेहतर कर सकते हैं।

मैं शायद इसे Befunge-98 में भी छोटा बना सकता था।

— Kasran
स्रोत

यदि आप चाहें तो इनलाइन स्निपेट को इनलाइन इंटरप्रिटर के साथ जोड़ सकते हैं। :)

— इंगो बुर्क

ओह, मैंने वास्तव में अभी तक स्निपेट की जांच नहीं की है। मैं देख लूँगा, धन्यवाद!

— कासरन

यदि इनपुट में कोई स्थान है तो यह काम नहीं करता है। यह अनुक्रम में एक अनंत लूप में जाता है >$! _क्योंकि आपको उस समय स्टैक पर दो शून्य मिले हैं जब आप गैर-शून्य मान की उम्मीद कर रहे हैं।

— जेम्स होल्डरनेस

4

PHP - 103 98 80 अक्षर

(str_rot13 () का उपयोग नहीं कर रहा है)

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

— अरनौद ले ब्लांक
स्रोत

4

डेल्फी, 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.एक चरित्र बचाता है :)

— रूटर वैन निफ्ट्रिक

@ सॉकर वैन निफ्ट्रिक: अच्छी जगह है! मैं इसे तदनुसार अपडेट

— करूंगा

4

हास्केल, 100 वर्ण

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

— MtnViewMark
स्रोत

3

पर्ल 6 (54)

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

— ब्रूस आर्मस्ट्रांग
स्रोत

3

जावा 251 चार्ट

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

पायथन 3 (107)

ठीक है, मैं अब इस सवाल का जवाब देना बंद करने का वादा करता हूं, लेकिन मुझे पायथन में डीसी के जवाब को हराने के लिए मजबूर होना पड़ा। यह शायद मुझ पर एक व्यक्ति के रूप में खराब रूप से प्रतिबिंबित होता है :)।

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 वर्ण

ठीक है, मुझे पता है कि यह धागा लंबा मर चुका है, लेकिन मैं लंबे (लंबे) सी-सॉल्यूशन को खड़ा नहीं कर सका, जो क्लैंग पर भी संकलन नहीं करता है (लेकिन जीसीसी पर है)।

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, और ऐसा लगता है कि ˜इस मामले में एक सेशन नहीं है और इसे काटा जा सकता है।

— रॉबी

@ robbie0630: सच है। पता नहीं क्यों मेरे पास था। धन्यवाद। :)

— एमिगा

2

PHP - 41 वर्ण

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

— ircmaxell
स्रोत

5

-1 री-वाॅरिंग के लिए।

— 21:39 पर रेयनोस

2

जावास्क्रिप्ट 1.8, 106

alert(prompt().replace(/\w/g,function(c)String.fromCharCode(c.charCodeAt()+(c.toLowerCase()<'n'?13:-13))))

जावास्क्रिप्ट, 115

alert(prompt().replace(/\w/g,function(c){return String.fromCharCode(c.charCodeAt()+(c.toLowerCase()<'n'?13:-13))}))

यह समाधान वर्ण कोड में 13 जोड़कर समस्या का हल करता है यदि प्रश्न में वर्ण वर्णमाला के पहले छमाही में है, या 13 को घटाकर यदि यह दूसरी छमाही में है।

— केसी चु
स्रोत

आप को बचा सकता है 7 की जगह के आधार पर पात्रों +(c.toLowerCase()<'n'?13:-13))के साथ -13+26*/[a-m]/i.test(c)।

— याकूब

2

CHIQRSX9 + , 1

आपको समस्या के लिए सही उपकरण का उपयोग करना होगा।
CHIQRSX9 + ट्यूरिंग पूर्ण है, और यह मानक चैनलों से पढ़ और लिख सकता है C।

— जोहान्स कुह्न
स्रोत

5

@ nyuszika7h इस प्रश्न के लिखे जाने से पहले भाषा का आविष्कार किया गया था, इसलिए यह मान्य है।

— जोहान्स कुह्न

1

यह अभी भी उन चीजों में से एक है, जिनके लिए इसका आविष्कार किया गया था। मुझे धोखा देने जैसा लगता है।

— nyuszika7h

7

@ nyuszika7h और गोल्फ-गोल्फ का आविष्कार कोड-गोल्फ चुनौतियों में जीतने के लिए किया गया था। क्या आपको लगता है कि धोखा भी है?

— जोहान्स कुह्न

2

@Mego इस जवाब के एक साल बाद लिखे जाने पर उन मानकों को लागू करना शायद ही उचित है।

— दरवाज़े

2

मेटागोल्फस्क्रिप्ट को एक अलग नियम द्वारा निषिद्ध है

— मेगो

2

सी, 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

समर्थन के लिए धन्यवाद। मुझे लगता है कि गियर में अपना सिर लाने के लिए मुझे कुछ पोस्ट करने की ज़रूरत थी। मैं जल्द ही इन चुनौतियों में से अपना हाथ आजमाने जा रहा हूं।

— टॉरमिस्ट

2

जावास्क्रिप्ट, 177 बाइट्स

यह मानता है कि दो कार्य हैं, प्रिंट और रीडलाइन:

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

लिस्प्लिस्प (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
स्रोत

क्या यह कार्यान्वयन के साथ एक वास्तविक भाषा है? यदि हां, तो क्या आप इसे लिंक कर सकते हैं?

— जो किंग

@JoKing विकिपीडिया TIO

— बेंजामिन Urquhart

@BenjaminUrquhart हां, लिस्प एक भाषा है। लिस्प्लिस्प हालांकि, मुझे कोई सबूत नहीं मिला है

— जो राजा

@ जोकिंग ओह मैं देख रहा हूं। शायद वह इस बात का जिक्र कर रहा था?

— बेंजामिन अर्कहार्ट

1

यहाँ LazyK का अनुवादक है (यह केवल SKI संयोजक कलन का कार्यान्वयन है)। gist.github.com/SYZYGY-DEV333/d74ca36b9a4c504b25c0a2380203c98d

— SYZYGY-DEV 333

2

8086 मशीन कोड, 27 बाइट्स

unassembled:

        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, लंबाई में CX। आउटपुट स्ट्रिंग बफर पर DI।

परीक्षण आईबीएम पीसी डॉस प्रोग्राम आउटपुट:

डाउनलोड R13.COM परीक्षण कार्यक्रम (पीसी डॉस)।

— 640KB
स्रोत

1

हास्केल - 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)

1

के, ३१

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

— tmartin
स्रोत

{x^a(,/-13 13#\:a:.Q.A)?x}के लिए 26 बाइट्स

— streetster

1

Tcl, 74 वर्ण

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

— जोहान्स कुह्न
स्रोत

ROT-13 ट्रांसफॉर्म स्टैंडर्ड इनपुट

बैश, 23 बाइट्स

बैश - 5 वर्ण

पायथन 2, 34 बाइट्स

Befunge - 7x30 = 210 6x26 = 156 वर्ण

पुराना संस्करण

रूबी - 60 57 38 37 चार्ट

परीक्षा

विम, 5 कीस्ट्रोक्स

C - 83 79 वर्ण

पायथन (117 बाइट्स)

आर, 37 बाइट्स

Befunge-93, 85 (ग्रिड: 41x3 = 123)

PHP - 103 98 80 अक्षर

डेल्फी, 110

हास्केल, 100 वर्ण

पायथन 3 (107)

C: 69 68 वर्ण

05AB1E , 13 12 बाइट्स

PHP - 41 वर्ण

CHIQRSX9 + , 1

सी, 136 बाइट्स

जावास्क्रिप्ट, 177 बाइट्स

लिस्प्लिस्प (16,636)

8086 मशीन कोड, 27 बाइट्स

हास्केल - 112 वर्ण

के, ३१

Tcl, 74 वर्ण