सीज़र-साइफर-उन्माद


22

सीज़र साइफर एक बहुत ही सरल प्रतिस्थापन बीजलेख जहां प्रत्येक अक्षर द्वारा एक निश्चित ऑफसेट (ए करने के लिए चारों ओर जेड पाशन) स्थानांतरित कर दिया जाता है। इसी तरह, हम मुद्रण योग्य ASCII वर्णों के सेट के लिए एक सीज़र साइबर भी कर सकते हैं। कोड अंक 0x20 से 0x7E तक ये 95 वर्ण हैं। किसी दिए गए ऑफ़सेट के लिए d, हम कोड पॉइंट Cको मैप करते हैं

(C - 32 + d) % 95 + 32

जो कि सभी वर्णों को शिफ्ट करता है dऔर ~अंतरिक्ष से चारों ओर लूप करता है। इस श्रेणी के बाहर के वर्ण (नियंत्रण वर्ण जैसे newlines, tabs, और ASCII श्रेणी के बाहर वर्ण) अप्रभावित हैं।

आप दो प्रोग्राम या फ़ंक्शन (संभावित रूप से विभिन्न भाषाओं में) लिख सकते हैं, जो एक ऑफसेट dऔर एक स्ट्रिंग लेते हैं । पहले प्रोग्राम को इनपुट के सीज़र साइबरफ़ॉर्म को वापस करना या प्रिंट करना चाहिए। दूसरे प्रोग्राम को प्रतिलोम सीज़र साइबर (यानी ऑफ़सेट का उपयोग करके -d) वापस लौटना चाहिए या प्रिंट करना चाहिए । आप STDIN, कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले सकते हैं।

चीजों को और अधिक रोचक बनाने के लिए, दूसरे कार्यक्रम में पहले कार्यक्रम का सीज़र साइबर होना चाहिए। यही है, अगर आप पहले प्रोग्राम के सोर्स कोड को खुद से पास करते हैं, तो कुछ गैर-शून्य ऑफसेट के लिए d, आउटपुट को दूसरा प्रोग्राम होना चाहिए।

दोनों प्रोग्राम, साथ ही साथ इनपुट स्ट्रिंग्स में केवल मुद्रण योग्य ASCII वर्ण, नई सूची और टैब होना चाहिए। किसी भी कार्यक्रम में कोई टिप्पणी नहीं हो सकती या अपने स्वयं के स्रोत कोड, फ़ाइल नाम या प्रक्रिया आईडी को प्रत्यक्ष या अप्रत्यक्ष रूप से पढ़ा जा सकता है।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है। चूंकि दोनों कार्यक्रमों का आकार समान होना चाहिए, इसलिए आपको इसे केवल एक बार गिनना होगा।

जवाबों:


12

Cjam, 40 38 37 बाइट्स

फ़ॉरवर्ड साइरफ़:

 q~'~),32>_@m<er "o|%|'*10<]>k<cpZ"_-

उलटा साइफर:

"s!)!+.54@aBo>gt"$q~'~),32>_@m>er\$a/

और दूसरा कार्यक्रम अंतर के साथ पहले वाले का साइबरफेयर है 2


यह काम किस प्रकार करता है

मैं चीजों का परीक्षण करते समय शुद्ध भाग्य पर इस जवाब के साथ आया था।

सबसे पहले, Cypher भागों:

q~'~),32>_@m<er
q~                 "Take the input and evaluate it";
  `~)              "Get the next character after the printable ASCII range";
     ,32>          "Get all printable ASCII characters":
         _@        "Copy the printable ASCII string and bring the cypher difference"
                   "on top of stack";
           m<      "Forward rotate the copy of printable ASCII string by difference";
                   "In case of inverse Cypher, this is m> to reverse rotate the string";
             er    "Transliterate to complete the forward/inverse Cypher";

अब मुश्किल भाग का स्पष्टीकरण आता है।

प्रमुख परिवर्तन हैं

<space> -> "     // Empty space to string conversion
Z -> \           // Character Z in an useless string to swap operation
_ -> a           // Copy operation to wrapping in an array
- -> /           // Set subtraction to string splitting

तो पहला कार्यक्रम है

 q~'~),32>_@m<er "o|%|'*10<]>k<cpZ"_-
 q~'~),32>_@m<er                          "no-op space, Forward cypher, no-op space";
                 "o|%|'*10<]>k<cpZ"       "Useless String (Actually not)";
                                   _      "Copy it and ..."
                                    -     "remove all alphabets of copy from original";

और दूसरा कार्यक्रम है

"s!)!+.54@aBo>gt"$q~'~),32>_@m>er\$a/
"s!)!+.54@aBo>gt"                       "Cypher of first part of first program"
                                        "with difference of 2";
                 $q~'~),32>_@m>er\$a/   "Cypher of the useless string of first program";
                                        "with difference 2";
                 $                      "Sort the first program's main part's cypher";
                  q~'~),32>_@m>er       "Program to reverse cypher";
                                 \$     "Swap the cypher to the top of stack and sort it";
                                   a    "Wrap it in array";
                                    /   "Split the output string on an array, which";
                                        "always returns the output in an array as there";
                                        "are no occurrences of an array in a string";

इनपुट की तरह है "<escaped string to be cyphered>" <difference>

उदाहरण के लिए:

"abcd" 4

और पहले प्रोग्राम का आउटपुट है

efgh

और दूसरे कार्यक्रम की है

]^_`

इसे यहाँ ऑनलाइन आज़माएँ


कि 40 बाइट्स नहीं हैं? यह भी ऑनलाइन दुभाषिया में एक त्रुटि देता है (Arraylists लागू नहीं होने पर कुछ)
Def

@Deformyer ने बाइट काउंट को सही किया। आप इनपुट क्या दे रहे हैं?
ऑप्टिमाइज़र

हाँ मेरे बुरे, मैंने गलत क्रम में तर्कों का इस्तेमाल किया।
डेस

'' q ~ '~), 32> _ @ m <er "9} o |% |' * 10 <]> k <cp}]" _- "2 'काम नहीं करता है (java.lang.RuntimeException: अनपेक्षित})
डिफ

1
@Deformyer आपको उस स्ट्रिंग में उद्धरणों से बचना होगा
अनुकूलक

7

अजगर 2, 147

स्पष्ट रूप से मैंने इस बारे में बहुत कठिन नहीं सोचा था, क्योंकि यह पायथन में निरर्थक होगा। बस दो अलग-अलग कार्यक्रम हैं, एक स्ट्रिंग में अप्रयुक्त एक के साथ।

दो कार्यक्रमों के बीच ऑफसेट 39 है।

आगे

फ़ंक्शन को परिभाषित करता है Z एक यूनिकोड स्ट्रिंग और एक ऑफसेट को स्वीकार करता है।

Z=lambda s,d:s.translate({i+32:(i+d)%95+32for i in range(95)})or u''and Z
"uE:F;=:XLd=rLfMK:GLE:M>`TBckjr`Be=a]qmckj?HKXBXBGXK:G@>`qmaVaHKXN__:G=X"

श्लोक में

फ़ंक्शन को परिभाषित करता है जिसे मैं एक यूनिकोड स्ट्रिंग और एक ऑफसेट स्वीकार करता हूं।

"d4)5*,)G;S,a;U<:)6;4)<-OC1RZYaO1R,PL`\RZY.7:G1G16G:)6/-O`\PEP7:G=NN)6,G"
I=lambda s,d:s.translate({i+32:(i-d)%95+32for i in range(95)})or u''and I

5

पायथन 3 - 248 बाइट्स

मेरा लक्ष्य पायथन वन-लाइनर के रूप में ऐसा करना था। लक्ष्य सफलता, लेकिन अब मैं गोल्फ को परेशान नहीं कर सकता।

एन्क्रिप्ट:

r=q="".__doc__[2];eval("p"+q+"int(''.join([c,ch"+q+"((o"+q+"d(c)-32+d)%95+32)][31<o"+q+"d(c)<127]fo"+q+" d in[int(input())]fo"+q+" c in input()))")or'\^UZ`smmyV[UZsGOwOT^ss[^PsOtx~}xPtp%!v~}tIG~|([^PsOt(|}$IR[^kPkUZGUZ`sUZ\a`sttIR[^kOkUZkUZ\a`sttt'

डिक्रिप्ट:

'Q&Q66Bssx$wssoFqOy+u!<6%6?&?6}#)<;;B~$}#<ow@w|6?&?6<<$6?&?6x<w=AGF?x=9MI?GF=qoGEP$6?&?6x<w=PEFKqz$6?&?64x4}#o}#)<}#%*)<==qz$6?&?64w4}#4}#%*)<===6=$';print("".join([c,chr((ord(c)-32-d)%95+32)][31<ord(c)<127]for d in[int(input())]for c in input()));

संपादित करें: मुद्रण योग्य ASCII सीमा के बाहर चार्ट को प्रभावित नहीं करने के लिए निश्चित

एन्क्रिप्ट से डिक्रिप्ट तक की शुरुआत 20 है। पहले ऑफसेट, फिर स्ट्रिंग, जैसे इनपुट द्वारा उपयोग करें

5
hello

व्याख्या

निम्नलिखित परिवर्तन प्रमुख हैं:

r -> '
' -> ;

पहला उपयोग करने की अनुमति देता है or, जबकि दूसरा अर्धविराम द्वारा एक स्ट्रिंग को अनदेखा करता है।

ध्यान दें कि "".__doc__[2]स्ट्रिंग लौटाता है r(से लिया गया str)। डिक्रिप्शन प्रोग्राम में सिंगल कोटेड स्ट्रिंग को बीच में आवारा उद्धरण होने से रोकने के लिए यह आवश्यक है।


5

रूबी, 131 125 बाइट्स

यहां मेरा अपना सबमिशन है (जो मैंने पहले अवधारणा के प्रमाण के रूप में लिखा था, लेकिन मैं किसी तरह अपने नियमों का उल्लंघन करने में कामयाब रहा)। मैं दो सबमिशन के बीच किसी भी कोड का पुन: उपयोग नहीं कर रहा हूं (मैं चाहता हूं कि आप लोग इसे हरा दें, आखिरकार), लेकिन इसके बजाय इसमें दो लाइनें होती हैं, जिनमें से एक को खिंचाव के साथ स्ट्रिंग में बदल दिया जाता है।

फॉरवर्ड साइफोर:

Y=->d,s{s.chars{|c|x=c.ord;$><<(x<32?x:(x-32+d)%95+32).chr}};Y
"tdu<cKSKe;@9JKST;TPt;eGJ<r[uss_PsjivPq_Pdjid<`\plbji`e;@JUUr"

उलटा साइबर:

"eUf-T<D<V,1*;<DE,EAe,V8;-cLfddPAd[ZgAbPAU[ZS-QMa]S[ZQV,1;FFc"
J=->d,s{s.chars{|c|x=c.ord;$><<(x<32?x:(x-32-d)%95+32).chr}};J

दोनों स्निपेट्स एक फ़ंक्शन को परिभाषित करते हैं ( Yपहले एक में, और Jदूसरे में), जो एक पूर्णांक और एक स्ट्रिंग लेता है और परिवर्तित स्ट्रिंग को STDOUT में प्रिंट करता है। कोड के दो टुकड़ों के बीच ऑफसेट है 40


4

oo कोड , 750 744 बाइट्स, दोनों कार्यक्रमों में उपयोग किए गए सभी कोड

बहुत लंबा है, लेकिन शायद यह सही उपकरण है ...

एन्क्रिप्ट:

CcCcccccccccCcYcccCCCccCcCcCccccccCcCcccccCcCcccCcCccCccCcCCccccCcCccccCCcCccccCCccCccCcCCcccCCCcCccccCcCCcCCcCCcCcCcCccccCCccCccCccCccCccCccCccCccccccCCCcCccCccCCcCcCcccCCcCcccCcCCcCCcCcCCccCCcCCcCCcCCcCCcCCcCCcCCcCCcCCcCcccccccCccccCccccCCccccCCcCccCCcccCccccccccccCcCccCccCccCccCcCCccCCcccCcCcCccCCcccCCCcCcccccccccccccCCccCccCcCcCcccCCccccccccccCcCccccccCcCccccCCcCccCccCCcCccccccccccCCccCcCcCcccccCcCccCcCCCcCccCccCCcCccCccCccCcCcccccCcCcccCCCcCcCccccCcCccCCcCCcCCcCcCCcccCcCCcCCcCCcCCcCCcCCcCCcCCcCCcCcCcccCccCCcccccCcCcccCcccccCcccCcccCccCccCCcCcccccccccccccCCCcccCcCcCcccCcccCCCcCccCccCccCcCCccCccCcCCCcCccccCcCccccccccCcCccCccCcCCccccccCccccccccCcccCCccCccCccCCcCCcCCcCCcCcCcCcccccCcCCcCCcCCcCCcCCcCCcCCcCccCcCCcccCCccCcCcccCCcccCCCcCC

डिक्रिप्ट:

SsSsssssssssSsisssSSSssSsSsSssssssSsSsssssSsSsssSsSssSssSsSSssssSsSssssSSsSssssSSssSssSsSSsssSSSsSssssSsSSsSSsSSsSsSsSssssSSssSssSssSssSssSssSssSssssssSSSsSssSssSSsSsSsssSSsSsssSsSSsSSsSsSSssSSsSSsSSsSSsSSsSSsSSsSSsSSsSSsSsssssssSssssSssssSSssssSSsSssSSsssSssssssssssSsSssSssSssSssSsSSssSSsssSsSsSssSSsssSSSsSsssssssssssssSSssSssSsSsSsssSSssssssssssSsSssssssSsSssssSSsSssSssSSsSssssssssssSSssSsSsSsssssSsSssSsSSSsSssSssSSsSssSssSssSsSsssssSsSsssSSSsSsSssssSsSssSSsSSsSSsSsSSsssSsSSsSSsSSsSSsSSsSSsSSsSSsSSsSsSsssSssSSsssssSsSsssSsssssSsssSsssSssSssSSsSsssssssssssssSSSsssSsSsSsssSsssSSSsSssSssSssSsSSssSssSsSSSsSssssSsSssssssssSsSssSssSsSSssssssSssssssssSsssSSssSssSssSSsSSsSSsSSsSsSsSsssssSsSSsSSsSSsSSsSSsSSsSSsSssSsSSsssSSssSsSsssSSsssSSSsSS

दिमागी अनुवाद:

+>>>+>,<[->[->+>+<<]>[-<+>]<<]>,[>++++[-<-------->]+<<+[<+>+++]<++++++++++>>[>-<-<+<-[>>>+<<<<]<-[+<-]+>>>>]<<[-]>>>[->[-<+<<+>>>]<[->+<]+<<+<<<[>[-]+[>+<+++]>++++++++++[<<->+>->-[<<<+>>>>]-[+>-]+<<<]<<]+>[->>+<<]>>->>-]<<<++++[->++++++++<]>.[-]>,]
+>>>->,<[->[->+>+<<]>[-<+>]<<]>,[>++++[-<-------->]+<<+[<+>+++]<++++++++++>>[>-<-<+<-[>>>+<<<<]<-[+<-]+>>>>]<<[-]>>>[->[-<+<<+>>>]<[->+<]+<<+<<<[>[-]+[>+<+++]>++++++++++[<<->+>->-[<<<+>>>>]-[+>-]+<<<]<<]+>[->>+<<]>>->>-]<<<++++[->++++++++<]>.[-]>,]

oo CODE एक ब्रेनफैक वैरिएंट है जहां केवल अक्षरों का मामला मायने रखता है।

यह पहली बाइट लेता है और इसके चरित्र कोड का उपयोग करता है d(इसलिए एक नई पंक्ति का अर्थ है d = 10)। बाकी इनपुट स्ट्रिंग है। EOF 0 है।


4

GolfScript, 95 64 बाइट्स, दोनों कार्यक्रमों में उपयोग किए गए सभी कोड

एन्क्रिप्ट:

0 0z{ 1)'[}??)9t:z21,--/; [84;%zt*84*84$|)21*|$Z!!\~'---|}`{)}%~

डिक्रिप्ट:

1!1{|!2*(\~@@*:u;{32-..0<!\95<&{u+95+95%}*32+}%[""] (...}~a|*~& 

इनपुट प्रारूप:

1 "0 0z{ 1)'[}??)9t:z21,--/; [84;%zt*84*84$|)21*|$Z!!\~'---|}`{)}%~"

व्याख्या

डिक्रिप्ट:

1!1                            # Push 0 1.
{                              # Define a block and evaluate it.
    |                          # Or.
    !2*(                       # Get 1 for encryption, or -1 for decryption.
    \~                         # Evaluate the input string.
    @@*:u;                     # u = d for encryption, or -d for decryption.
    {                          # For each character:
        32-                    # Subtract 32.
        ..0<!\95<&             # Test if it is in the printable range.
        {u+95+95%}*            # If so, add u (mod 95).
        32+                    # Add 32 back.
    }%
    [""] (...                  # Push an empty array and 4 empty strings.
}~
a                              # No-op.
|*~                            # Evaluate ""*(""|"") which does nothing.
&                              # Calculate []&"" which is empty.

एन्क्रिप्ट:

0 0                            # Push 0 0.
z                              # No-op.
{                              # Define a block and get its string representation.
    ...                        # See decryption code.
    |                          # This will be decoded into a }. The string will be truncated here when evaluated.
}`                             # Only the closing } will be truncated, but it is still used as the end of the block.
{)}%                           # Increment each character. Note that the braces before and after the block will also be incremented.
~                              # Evaluate the string.

3

जावास्क्रिप्ट (ईएस 7 ड्राफ्ट) - 167 165 बाइट्स

@ फैर्सम के स्ट्रिंग्स के उपयोग और @ मर्टिनबटनर के अर्धविराम के उपयोग से उधार लेना;)

एन्क्रिप्ट:

J=(s,d)=>s.replace(/[ -~]/g,x=>String.fromCharCode((x.charCodeAt()-32+d)%95+32));J
"eP<T-Qef<V;.95*,.PW$HUG&W0TAef{=;270V/;86k1*;k8-.PPAV,1*;k8-.i=PQS^[U-QMa]S[ZQQc"

डिक्रिप्ट:

"t_Kc<`tuKeJ=HD9;=_f3WdV5f?cPtu+LJAF?e>JGEz@9JzG<=__Pe;@9JzG<=xL_`djib<`\plbji``r"
Y=(s,d)=>s.replace(/[ -~]/g,x=>String.fromCharCode((x.charCodeAt()+63-d)%95+32));Y

उपयोग करने के लिए ऑफसेट: 55


1
खाली तारों के लिए विफल रहता है। इसलिए मुझे or <empty string> and <function>केवल करने के बजाय रखना था or <function>
feersum

@ Faersum यह अब तय हो गया है ... और 2 बाइट्स छोटे :)
15

हम्म, यह परिचित लग रहा है। ;)
मार्टिन एंडर

@ MartinBüttner मुझे नहीं पता कि आपका क्या मतलब है ...?)
nderscore

2

> <> (मछली) , 467 बाइट्स

एन्क्रिप्ट:

ffii{{~~__:0a('0'*!.0a('0'*22(!'(~$~_:}-}$-a*}+{{if~~:i:0({}?;__:{}84{}*__({}?\__:{} _{}70{}g_{})_{}?\4__{}8*-_{}+{}80{}g_%4_{}8*{}+\\sl||||||||||||||||||||||||||||9||||||||||||||9||||||||||||||||||||||||||||||||||||||||||||||||||||9
                                                                              >                      >                              >!;7f7-_{}!%_{}!<872-d_{}!&_{}!<[755(7(%~~_{}!<[55(7(_{}!*!*23a(_{}!'_{}!"55(7((~~_{}~~~o__'4'0.{{{o,

डिक्रिप्ट:

iill~~""bb=3d+*3*-$13d+*3*-55+$*+"'"b=!0!'0d-!.~~li""=l=3+~!B>bb=~!;7~!-bb+~!B_bb=~!#b~!:3~!jb~!,b~!B_7bb~!;-0b~!.~!;3~!jb(7b~!;-~!.__vo                            <              <                                                    <
##############################################################################A######################A##############################A$>:i:0b~!$(b~!$?;:50gb~!$)b~!$?^:88+:+(""b~!$?^88+:+b~!$-$-56d+b~!$*b~!$%88+:++""b~!"""rbb*7*31~~~r/

दो प्रोग्राम 3 से ऑफसेट हैं, और वे फॉर्म का इनपुट लेते हैं:

<2-digit offset> <text>

ऑफ़सेट 2 अंक का होना चाहिए, इसलिए 5 की ऑफ़सेट के रूप में दर्ज किया जाना चाहिए 05

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

यह छवि दोनों कार्यक्रमों द्वारा उपयोग किए गए वर्णों पर प्रकाश डालती है।

व्याख्या

मुख्य निर्माण जो इसे संभव बनाता है _{} -> b~!, जो डिक्रिप्शन प्रोग्राम में चार्ट की मनमानी लंघन की अनुमति देता है। कैसे?

Encrypt:
  _ : Mirror, but is a no-op if the program flow is horizontal
  { : Shift stack left
  } : Shift stack right

Decrypt:
  b : Push 11 to stack
  ~ : Pop top of stack
  ! : Skip the next instruction

सभी में, एन्क्रिप्शन प्रोग्राम कुछ भी नहीं करता है, लेकिन डिक्रिप्शन प्रोग्राम अगले निर्देश को छोड़ देता है। इसके बाद इसे बढ़ाया जा सकता है _{}! -> b~!$, जो इसके बजाय एन्क्रिप्शन प्रोग्राम में वर्णों की मनमानी लंघन की अनुमति देता है ।

इसके अलावा, कार्यक्रम के बाकी हिस्सों में से अधिकांश संख्याओं को आगे बढ़ा रहे हैं, उन नंबरों पर संचालन कर रहे हैं और फिर उन्हें पॉप करने के तरीके ढूंढ रहे हैं। उदाहरण के लिए, एक उपयोगी निर्माण है ~~ -> "", जो एन्क्रिप्शन प्रोग्राम के लिए दो मानों को पॉप करता है, लेकिन डिक्रिप्शन प्रोग्राम में कुछ भी नहीं धकेलता है।


> <>, 149 बाइट्स

यहां कम दिलचस्प संस्करण है, जो इस तथ्य का उपयोग करता है कि निर्देशों के माध्यम से पारित नहीं किया जाता है 2 डी भाषाओं में प्रभावी रूप से टिप्पणियां हैं।

एन्क्रिप्ट:

i68*:@-a*i@@-+i~v
4:v?)g31:;?(0:i:/8
(?v48*-+03g%48*+\*
_~\of0.   .1+1fo/
j*+:zq<6B99A6=qz6g
53Ji?C58/8;?r0?C5:
C?EiJ4r?<EFJ3;EtEg
:tAC5EK8l5tKK86t*i

डिक्रिप्ट:

^+-~/5"V~^55" ^sk
)/k4}\(&/04|%/^/$-
|4k)-~" %(\y)-~ Q~
TsQd[%#ttt#& &[d$
_~ /of1+7..6+2fo+\
*(?^48*-$-04g%48*/
84:^?)g41:;?(0:i:\
/i68*:@-a*i@@-+i~^

दो कार्यक्रमों को 84 से ऑफसेट किया जाता है, और ऊपर के समान इनपुट लेते हैं। पहला निर्देश तय करता है कि प्रोग्राम का कौन सा आधा भाग निष्पादित करना है, i(इनपुट) एन्क्रिप्शन प्रोग्राम में प्रोग्राम फ्लो को सही बनाए रखता है, और^ डिक्रिप्शन प्रोग्राम में रीडायरेक्टिंग प्रोग्राम फ्लो ऊपर की तरफ (चारों ओर से लूपिंग और नीचे से वापस आ रहा है) प्रवाह करता है।

व्याख्या

एन्क्रिप्शन प्रोग्राम के प्रासंगिक आधे के लिए (डिक्रिप्शन प्रोग्राम समान है):

i                       read first input digit as char
68*:@-a*                subtract 48 (ASCII "0") and multiply by 10, keeping another 48 on the stack
i                       read second input digit as char
@@-+                    subtract 48 and add to 10*(first digit), giving the offset
i~                      read in space and discard it

--- LOOP ---
:                       copy the offset
i:                      read input char
:0)?;                   check if less than 0 (i.e. EOF) and terminate if so
:13g)?v                 check if greater than ~ in cell (1,3) and drop down if so
48*(?v                  check if less than 32 and drop down if so
48*-+03g%48*+           calculate Caesar shift of the char, fetching 95 from (0,3)

of1+1.                  repeat loop
of0.                    repeat loop

कोडिंग टूल

यह ऊपर के बाकी पोस्ट से संबंधित नहीं है, लेकिन मुझे लगा कि मैं इसे पोस्ट करूंगा क्योंकि मुझे इसका उपयोग करने की आवश्यकता है: P

for(var i=0;i<95;++i){var option=document.createElement("option");option.text=i;document.getElementById("offset").add(option)};function update(m){if(m==1)var code=document.getElementById("in").value;else var code=document.getElementById("out").value;var offset=parseInt(document.getElementById("offset").value);var output="";for(var i=0;i<code.length;i++){var n=code[i].charCodeAt(0);if(n<32||n>127)output+=code[i];else{var c=(n-32+offset*m)%95;output+=String.fromCharCode(c<0?c+95+32:c+32)}}if(m==1)document.getElementById("out").value=output;else document.getElementById("in").value=output};
<html><body><textarea id="in" onkeyup="update(1)" rows=5 style="width:100%"></textarea><textarea id="out" rows=5 style="width:100%" onkeyup="update(-1)"></textarea><select id="offset" onchange="update(1)"></select></body></html>


1

पर्ल - 131

यह कमांड लाइन आर्ग्स से इनपुट लेता है।

We;{for(split//,$ARGV[1]){print chr(((ord$_)-32+$ARGV[0])%95+32)}};q!LUXmYVROZttqi'8-<AvCnaVXOTZeINXmmmUXJiEnrxwri'8-<AuCnj~zpxwnc!

इसे 26 से शिफ्ट करने से दूसरा मिल जाता है:

q U6!*-B.+'$/IIF>[lapuKwC6+-$)/:}#-BBB*-~>yCGMLE>[lapuJwC?SOEMLC88U,;for(split//,$ARGV[1]){print chr(((ord$_)-32-$ARGV[0])%95+32)};

@ मर्टिन ब्यूटनर वाह, एक अपवोट! यह वास्तव में काम करता है ?
केएसएफटी

जहाँ तक मैं बता सकता हूँ वह करता है;)
मार्टिन एंडर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.