डिक्रिप्शन फ़ंक्शन
आपको एक प्रोग्राम लिखना होगा जो एक एन्क्रिप्टेड स्ट्रिंग लेता है और इसे विशिष्ट नियमों के अनुसार डिक्रिप्ट करता है और फिर इसे प्रिंट करता है। डिक्रिप्शन दो ऑपरेशन करने से होगा।
नमूना इनपुट तर्क 1 (एन्क्रिप्टेड स्ट्रिंग)
HGJILKBADCFE
ऑपरेशन 1:
दूसरी छमाही के साथ स्ट्रिंग के पहले आधे हिस्से को स्वैप करें, जिसे आपको छोड़ देना चाहिए:
BADCFEHGJILK
ऑपरेशन 2:
प्रत्येक दो पात्रों को एक दूसरे के साथ स्वैप करें जैसे कि स्वैपिंग चरित्र 1 के साथ 2, 3 के साथ 4, आदि, जो आपको डिक्रिप्टिंग स्ट्रिंग के साथ छोड़ देना चाहिए:
ABCDEFGHIJKL
दिशानिर्देश:
इनपुट तर्क 1 में केवल बड़े अक्षर होंगे
इनपुट तर्क 1 की लंबाई 2 और 100 वर्णों के बीच होगी
इनपुट तर्क 1 की लंबाई हमेशा एक सम संख्या होगी
अधिमानतः इनपुट कमांड लाइन (जैसे नीचे) से लिया जाएगा।
एक और टेस्ट केस
MPORQTSVUXWZYBADCFEHGJILKNइनपुट है, आउटपुट हैABCDEFGHIJKLMNOPQRSTUVWXYZ
मेरा प्रयास
import sys
_,a=sys.argv
b=len(a)//2
s=a[b:]+a[:b]
print(''.join(x+y for x,y in zip(s[1::2],s[::2])))
जवाब
जे , 15 बाइट्स
[:,_2|.\-:@#|.]
इसे ऑनलाइन आज़माएं!
सूत्र का सीधा कार्यान्वयन।
थोड़ा और अधिक दिलचस्प (जे गोल्फ के लिए उपयोगी नहीं है, लेकिन शायद एक और लंगड़ा के लिए) यह है कि एल्गोरिथ्म को स्कैन के साथ हल किया जा सकता है:
- सबसे पहले एक लेने
1के बाद-1 3से,-1 3सूची की लंबाई पर निर्भर दोहराया। - उस सूची को स्कैन करें।
- आधी सूची की संख्या को घुमाएं।
- उन नंबरों के अनुसार मूल को क्रमबद्ध करें।
J में डेमो के लिए TIO देखें।
रूबी -p , 48 47 बाइट्स
$_=$_[l= ~/$//2,l]+$_[0,l];gsub /(.)(.)/,'\2\1'
इसे ऑनलाइन आज़माएं!
ऑपरेशन 1 को बंटवारे द्वारा नियंत्रित किया जाता है $_(पूर्वनिर्धारित वैश्विक चर जिसमें इनपुट शामिल है) समान लंबाई के दो सबस्ट्रिंग में; ~/$/इनपुट की लंबाई देता है। फिर gsub /(.)(.)/,'\2\1'प्रत्येक वर्ण की जोड़ी को स्वैप करके ऑपरेशन 2 को पूरा करता है। ( -pझंडे के साथ , gsubबिना रिसीवर के कोई कार्य नहीं करता है $_।)
05AB1E , 13 12 बाइट्स
D2äRJ2ι`s.ιJ
इसे ऑनलाइन आज़माएं!
-1 एक गोल्फ टिप के लिए धन्यवाद @ केविन द्वारा मैंने एक और उत्तर पर देखा
व्याख्या की
D2äRJ2ι`s.ιJ
- इनपुट डुप्लिकेट (
D) - इसे 2 विखंडू में विभाजित करें (
2ä) - सूची को उल्टा करें और इसे एक स्ट्रिंग में शामिल करें (
RJ) - हर दूसरे वर्ण पर उस स्ट्रिंग को अनइंस्टाल करें (
2ι) - स्टैक पर निर्बाध स्ट्रिंग से सभी आइटम पुश करें (`` `)
- उन वस्तुओं को इंटरलेव करें (
.ι) - और परिणामी सूची में शामिल हों (
J)
एपीएल + विन, 24 22 बाइट्स
जो राजा को -2 बाइट्स धन्यवाद
स्ट्रिंग के इनपुट के लिए संकेत:
,⌽n⍴⊖(⌽n←⌽2,.5×⍴s)⍴s←⎕
इसे ऑनलाइन आज़माएं! दरोगल क्लासिक के सौजन्य से
आर , 78 80 79 बाइट्स
संपादित करें: बग-स्पॉटिंग के लिए डिंगस के लिए +2 बाइट्स, और पाजोंक के लिए -1 बाइट धन्यवाद
n=nchar(s<-scan(,''));o=1:n;cat(substring(s,p<-(o+n/2-2+2*o%%2)%%n+1,p),sep='')
इसे ऑनलाइन आज़माएं!
R कंसोल के माध्यम से दिया गया इनपुट (जिसे R कार्यक्षेत्र के लिए 'कमांड लाइन' माना जा सकता है)।
आर को Rscriptहेल्पर फ्रंट-एंड का उपयोग करके एक (नॉन-आर) शेल से भी आमंत्रित किया जा सकता है , जो कमांड-लाइन तर्कों को कॉल का सीधे पालन करने की अनुमति देगा, जिस स्थिति में एक संशोधित कार्यक्रम 87 बाइट्स हो सकता है और उपयोग कर सकता है Rscript decrypt.r HGJILKBADCFE।
डिकोड किए गए अक्षरों की स्थिति की गणना करता है, और फिर पुन: व्यवस्थित स्ट्रिंग आउटपुट करता है।
टिप्पणी की:
n=nchar( # n = number of characters in...
s<-scan(,'')); # s = the input.
o=1:n; # o = sequence from 1 to n
p= # p = positions of decoded characters:
(o+n/2-1 # - reverse the first & second halves of o
# by adding n/2-1
# (will be fixed with final modulo below)
+2*o%%2-1) # - then add 2 at every odd position
# and subtract 1 from all, so in effect
# adding to odds & subtracting from evens
%%n # - all modulo n
+1 # - add 1 to get 1-based indices
cat( # output:
substring(s,p,p),sep='') # characters of s from positions p to p
जेली , 7 बाइट्स
ŒHṚFs2U
इसे ऑनलाइन आज़माएं!
समान रूप से 7 बाइट्स ṙLH$s2U,।
व्याख्या
ŒHṚFs2U Main Link
ŒH Split into two halves of similar length
Ṛ Reverse the order (swap the two halves)
F Flatten back into a single string
s2 Slice into chunks of length 2
U Reverse each chunk
Output is implicitly as one string
अन्य ṙइसे $( Hस्ट्रिंग के उत्कीर्णन के द्वारा ) ओट Lकरता है और फिर चुनौती के दूसरे भाग के लिए भी यही काम करता है।
पायथन 3 , 75 बाइट्स
बिल्कुल जैसा कि पूछा गया: कमांड लाइन से इनपुट, एसटीडी के बारे में आउटपुट।
import sys
_,s=sys.argv
i=1
while s[i:]:print(end=s[i-len(s)//2]);i+=3|i%-2
इसे ऑनलाइन आज़माएं!
पायथन 2 , 52 बाइट्स
अगर हम किसी फंक्शन का उपयोग कर सकते हैं:
f=lambda s,i=1:s[i:]and s[i-len(s)/2]+f(s,i+3-i%2*4)
इसे ऑनलाइन आज़माएं!
इन सब के विचार इस बात का सूचकांक है \$i\$लंबाई की एक श्रंखला 'वें उत्पादन चरित्र \$n\$ है:
$$ i - \frac{n}{2} + (-1)^i $$
सामान्य पायथन अनुक्रमण शब्दार्थ के अधीन। यदि हम इसे पुनरावृत्त शैली में लिखते हैं, तो \ _$i\$'वें उत्पादन चरित्र है:
$$ a_i - \frac{n}{2} \text{ where } a_0 = 1 \text{ and } a_i = a_{i-1} + 3 - 4(i\%2) $$
कुछ पूर्वता के साथ छोटा है:
$$ a_i - \frac{n}{2} \text{ where } a_0 = 1 \text{ and } a_i = a_{i-1} + 3|(i\%-2) $$
पायथन 2 , 50 बाइट्स
f=lambda s,i=0:s[i:]and s[(i^1)-len(s)/2]+f(s,i+1)
इसे ऑनलाइन आज़माएं!
Sisyphus के विचारों को उधार लेते हुए , iआउटपुट का 'वें वर्ण' (i^1)-len(s)/2इनपुट के सूचकांक में वर्ण है । यहाँ, i^1साथ XOR है 1, जो पिछले बिट flips और इतने स्वैप भी / अजीब जोड़े 0<->1, 2<->3, 4<->5, ...
यहां एक ही लंबाई के लिए एक गैर-पुनरावर्ती विकल्प है, हालांकि यह उन पात्रों की सूची का उत्पादन करता है जो मुझे यकीन नहीं है कि अनुमति है।
lambda s:[s[(i^1)-len(s)/2]for i in range(len(s))]
इसे ऑनलाइन आज़माएं!
सी (जीसीसी) , 73 72 70 बाइट्स
डोमिनिक वैन एसेन के लिए धन्यवाद 2 बाइट्स सहेजा गया !!!
i;l;f(char*s){for(i=1;(l=strlen(s))/i;)putchar(s[(i+l/2-++i%2*2)%l]);}
इसे ऑनलाइन आज़माएं!
एक स्ट्रिंग इनपुट करता है और डिक्रिप्शन को आउटपुट करता है।
व्याख्या
अनुक्रमणिका को मैप करें ( \ पर शुरू)$0\$अंत तक), इनपुट स्ट्रिंग, \$s\$लंबाई \$l\$, इस पर स्थानांतरण द्वारा सही जगह पर \$\frac{l}{2}+1\$स्थानों और फिर वापस \$2\$विषम सूचकांकों के लिए। इस का उपयोग करते हुए \$\mod{l}\$की सही सूचकांक देता है \$s\$ अगले आउटपुट चरित्र के लिए।
जावास्क्रिप्ट (Node.js) ,
71
65 बाइट्स
s=>(s.slice(l=s.length/2)+s.slice(0,l)).replace(/(.)(.)/g,'$2$1')
इसे ऑनलाइन आज़माएं!
सहेजे गए 6 बाइट्स @ थैगी का धन्यवाद।
मूल 71 बाइट समाधान:
s=>(l=>s.slice(l)+s.slice(0,l))(s.length/2).replace(/(\w)(\w)/g,'$2$1')
यहाँ बहुत सरल सामान - मैंने एक आंतरिक फ़ंक्शन का उपयोग किया क्योंकि मुझे sliceकॉल को वैसे भी घेरना था - यह 4 बाइट्स बचाता है।
ब्रेकीलॉग , 8 बाइट्स
ḍ↔cġ₂↔ᵐc
इसे ऑनलाइन आज़माएं!
यह काम किस प्रकार करता है
ḍ↔cġ₂↔ᵐc
ḍ split in two halves
↔ reverse
c join
ġ₂ group with length two
↔ᵐ reverse each
c join
पायथन 3 , 91 बाइट्स
a=input();x=len(a)//2;b=a[x:]+a[:x];c=''
for i in range(0,len(b),2):c+=b[i+1]+b[i]
print(c)
इसे ऑनलाइन आज़माएं!
पिप , 21 बाइट्स
RV_M(JRV(a<>#a/2)<>2)
इसे ऑनलाइन आज़माएं!
व्याख्या
RV_M(JRV(a<>#a/2)<>2)
(a<>#a/2) split input into parts of size length/2
JRV reverse the list, and join it to string
<>2 split the joined string into parts of size 2
RV_M reverse each of those parts
implicit output
सी (जीसीसी) , 78 76 78 74 बाइट्स
छत के लिए धन्यवाद -4!
संपादित करें: ऑपरेटर पूर्ववर्ती मुद्दों से बचने के लिए OR के बजाय जोड़ का उपयोग करने के लिए वापस लौटाया गया।
स्ट्रिंग को विभाजित करने के बजाय, फ़ंक्शन स्ट्रिंग के बीच में शुरू होता है और पूरे स्ट्रिंग के चारों ओर लपेटता है। प्रत्येक दूसरे वर्ण को फ्लिप करने के लिए, इंडेक्स काउंटर की 1s स्थिति को निष्क्रिय करता है।
f(s,i,j)char*s;{for(i=strlen(s),j=0;write(1,s+(i/2+j++/2*2+j%2)%i,j<i););}
इसे ऑनलाइन आज़माएं!
यदि प्रोग्राम बिल्कुल कमांड लाइन से लेना चाहिए: 82 बाइट्स
main(i,s,j)char**s;{for(i=strlen(*++s),j=0;write(1,*s+(i/2+j++/2*2+j%2)%i,j<i););}
इसे ऑनलाइन आज़माएं!
स्टैक्स , 10 बाइट्स
ü♠yαæ♠╟«ºñ
इसे चलाएं और डीबग करें
क्या एक अद्भुत ऑनलाइन दुभाषिया।
लिंक कोड के अनपैक्ड संस्करण के लिए है।
व्याख्या
;%h/r$2/Frp ; copy input % get it's length h halve it / split input into parts of that size r reverse $ join to string
2/ split into parts of size 2
F for each element in the resulting array:
rp reverse, and print without newline.
के (ngn / k) , 17 बाइट्स
,/|'0N 2#,/|2 0N#
इसे ऑनलाइन आज़माएं!
फैक्टर , 89 बाइट्स
: d ( s -- s ) halves swap [ >array ] bi@ append 2 group [ reverse ] map concat >string ;
इसे ऑनलाइन आज़माएं!
आर , 64 63 बाइट्स
m=matrix;intToUtf8(m(m(utf8ToInt(scan(,"")),,2)[,2:1],2)[2:1,])
इसे ऑनलाइन आज़माएं!
डोमिनिक वैन एसेन की तुलना में एक अलग दृष्टिकोण लिया , जिसने एक बाइट को नीचे गिरा दिया। उलटफेर करने के लिए मैट्रिक्स पुनर्वसन / अनुक्रमण का उपयोग करता है।
अघोषित:
s <- utf8ToInt(scan(,"")) # read input and convert to a list of byte values
m <- matrix(s,,2) # convert to a Nx2 matrix, filling down by columns
m <- m[,2:1] # reverse the columns of the matrix (flip the halves)
m <- matrix(m,2) # convert to an Nx2 matrix, filling down by the columns
m <- m[2:1,] # reverse the rows (swap adjacent characters)
intToUtf8(m) # convert back to string
बैश + सेड, 57 बाइट्स
कमांड लाइन तर्क के रूप में इनपुट लेता है।
<<<"${1:${#1}/2}${1:0:${#1}/2}" sed 's/\(.\)\(.\)/\2\1/g'
इसे ऑनलाइन आज़माएं!
बर्लेस्क , 17 बाइट्स
iRsa2./!!2co)<-++
इसे ऑनलाइन आज़माएं!
विवरण:
iR # Generate all rotations of the input string
sa # Duplicate and get length (which equals string length)
2./ # Divide by two
!! # And grab the string that's been rotated that many times
2co # Split the rotated string into chunks of two
<- # Reverse each chunk
++ # Join together and implicitly output
जाप -P , 9 बाइट्स
éUÊz)ò mw
कोशिश करो
éUÊz)ò mw :Implicit input of string U
é :Rotate right by
UÊ : Length of U
z : Floor divided by 2
) :End rotate
ò :Partitions of length 2
m :Map
w : Reverse
:Implicitly join and output
चारकोल , 13 बाइट्स
⭆⪪⪫⮌⪪θ⊘Ｌθω²⮌ι
इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:
θ Input string
Ｌ Length
⊘ Halved
⪪θ Split input string into substrings of this length
⮌ Reverse
⪫ ω Join together
⪪ ² Split into substrings of length 2
⭆ Map over substrings and join
ι Current substring
⮌ Reversed
Implicitly print
रेटिना 0.8.2 , 36 बाइट्स
((.)+?)((?<-2>.)+)$ $3$1 (.)(.) $2$1
इसे ऑनलाइन आज़माएं! स्पष्टीकरण: पहला चरण कुछ वर्णों के मिलान के लिए .NET बैलेंसिंग समूह का उपयोग करता है, $1जबकि अभी भी वर्णों की समान संख्या से मेल खाता है $3। $#2प्रत्येक वर्ण के लिए वेतन वृद्धि में मिलान किया गया $1और प्रत्येक वर्ण के लिए decrements में मिलान हुआ, $3लेकिन यह शून्य से नीचे नहीं बढ़ सकता है, इसलिए $1स्ट्रिंग के अंत तक पहुंचने के लिए स्ट्रिंग के पहले छमाही का उपभोग करने के लिए मजबूर किया जाता है। दूसरा चरण फिर आसन्न पात्रों के जोड़े को झटकता है। (इसके अलावा ASCII कला bewbs।)
मठगोल्फ , 10 बाइट्स
h½/xy2/mx~
इसे ऑनलाइन आज़माएं।
स्पष्टीकरण:
h # Get the length of the (implicit) input-string (without popping)
# i.e. "HGJILKBADCFE" → "HGJILKBADCFE" and 12
½ # Halve this length
# → "HGJILKBADCFE" and 6
/ # Split the string into parts of that size
# → ["HGJILK","BADCFE"]
x # Reverse this pair
# → ["BADCFE","HGJILK"]
y # Join it back together to a string
# → "BADCFEHGJILK"
2/ # Split it into parts of size 2
# → ["BA","DC","FE","HG","JI","LK"]
m # Map over each pair:
x # Reverse the pair
# → ["AB","CD","EF","GH","IJ","KL"]
~ # Pop and push all strings separated to the stack
# → "AB", "CD", "EF", "GH", "IJ", and "KL"
# (after which the entire stack joined together is output implicitly)
# → "ABCDEFGHIJKL"
लाल , 89 बाइट्स
func[s][move/part s tail s(length? s)/ 2
rejoin collect[foreach[b a]s[keep rejoin[a b]]]]
इसे ऑनलाइन आज़माएं!
लूआ , 67 बाइट्स
a=...b=#a//2print(((a:sub(b+1)..a:sub(1,b)):gsub('(.)(.)','%2%1')))
इसे ऑनलाइन आज़माएं!
सबसे पहले, स्ट्रिंग का उपयोग करके दो subकार्यों में कटौती की जाती है और फिर रिवर्स ऑर्डर में वापस मिलाया जाता है। फिर, gsubवर्णों के जोड़े को स्वैप करने के लिए उपयोग किया जाता है।
वोल्फ्राम भाषा (गणितज्ञ) , 64 51 बाइट्स
#[[#+UnitStep@#&@Array[#+(-1)^#&,L=Tr[1^#],-L/2]]]&
इसे ऑनलाइन आज़माएं!
Sisyphus के पायथन समाधान का पोर्ट
सीजेएम , 13 बाइट्स
q2/::\_,2//:\
इसे ऑनलाइन आज़माएं!
पर्ल 5 -pF , 40 बाइट्स
for$p("."x(@F/2),"."){s/($p)($p)/$2$1/g}
इसे ऑनलाइन आज़माएं!
काव्य , 472 बाइट्स
DECODING THINGS:A BRIEFING
o,o,hello!i am agent Q
nah,Q`s chosen by an infamous phoney
a misprint!oh,sorry!am i sorry
i am agent J.W,tech/A.I hacker
i see a piece o code,i am trying at a means on how i decode it
what i am doing:i am laying all A-Z clearly along a pathway
midway,put in zeros(O,O)cause J.W needs it to split em
i shift em in tandem,i get B,A
lastly,if it leaves you a letter,it is moved
o,then i am doing A-Z again,it is taken to a shift
ah ha!spying is EZ
इसे ऑनलाइन आज़माएं!