चलो इसे एन्क्रिप्ट करें!


12

चुनौती

नीचे दिए गए नियमों का उपयोग करके चुनौती दी गई स्ट्रिंग को एन्क्रिप्ट करने की है। स्ट्रिंग में केवल लोअरकेस वर्णमाला , अंक और / या रिक्त स्थान होंगे

एक वर्ण के बराबर

अब, सबसे पहले आपको यह जानना होगा कि प्रत्येक वर्ण के "समकक्ष" को कैसे खोजना है।

यदि चरित्र एक व्यंजन है, तो यह समान होने का तरीका है:

1) List all the consonants in alphabetical order
    b c d f g h j k l m n p q r s t v w x y z
2) Get the position of the consonant you are finding the equivalent of.
3) The equivalent is the consonant at that position when starting from the end.

उदाहरण: 'h' और 't' एक दूसरे के समतुल्य हैं क्योंकि 'h', 't' क्रमशः आरंभ और अंत से 6 ठी स्थिति में हैं।

स्वर / अंकों के समतुल्य खोजने के लिए समान प्रक्रिया का पालन किया जाता है। आप क्रम में सभी स्वरों या अंकों (0 से शुरू) को सूचीबद्ध करते हैं और समान पाते हैं।

नीचे सभी पात्रों के समकक्षों की सूची दी गई है:

b <-> z
c <-> y
d <-> x
f <-> w
g <-> v
h <-> t
j <-> s
k <-> r
l <-> q
m <-> p
n <-> n

a <-> u
e <-> o
i <-> i

0 <-> 9
1 <-> 8
2 <-> 7
3 <-> 6
4 <-> 5

एन्क्रिप्ट करने के नियम

1) आप बाईं ओर से चलना शुरू करते हैं और दाईं ओर जाते हैं।

2) यदि वर्ण एक व्यंजन / अंक है, तो इसके समकक्ष लिया जाता है और यदि यह रिक्त स्थान है, तो एक रिक्त स्थान लिया जाता है।

3) यदि चरित्र एक स्वर है, तो आप इसे बराबर लेते हैं और विपरीत दिशा में चलना शुरू करते हैं। उदाहरण के लिए, यदि आप दाएं घूम रहे हैं और एक स्वर का सामना कर रहे हैं, तो उस चरित्र को एन्क्रिप्ट करें और फिर सबसे दाहिने अनएन्क्रिप्टेड वर्ण पर जाएं और बाईं दिशा में एन्क्रिप्ट करना शुरू करें, और इसके विपरीत।

4) आपको दो बार एक ही स्थिति में एक चरित्र पर विचार नहीं करना चाहिए। इनपुट में सभी वर्णों के शामिल होने तक चरणों का पालन किया जाना चाहिए।

5) इनपुट में कुल अक्षरों की संख्या (रिक्त स्थान सहित) आउटपुट में कुल वर्णों की संख्या के बराबर होनी चाहिए।

कृपया ध्यान दें कि एन्क्रिप्ट किए गए वर्ण आउटपुट में उस क्रम में दिखाई देते हैं जिसमें वे एन्क्रिप्ट किए गए थे।

अब मैं आपके लिए एक स्ट्रिंग एन्क्रिप्ट करता हूं।

String = "tre d1go3t is"
Moving left to right
"t" -> "h"
"r" -> "k"
"e" -> "o"
Vowel encountered. Now moving right to left.
"s" -> "j"
"i" -> "i"
Vowel encountered. Now moving left to right.
" " -> " "
"d" -> "x"
"1" -> "8"
"g" -> "v"
"o" -> "e"
Vowel encountered. Now moving right to left.
" " -> " "
"t" -> "h"
"3" -> "6"

Output -> "hkoji x8ve h6"

उदाहरण

"flyspy" -> "wqcjmc"
"hero" -> "toek"
"heroic" -> "toyike"
"ae" -> "uo"
"abe" -> "uoz"
"the space" -> "htoo jmuy"
"a d1g13t" -> "uh68v8x "
"we xi12" -> "fo78i d"
"this is a code" -> "htioj ixej uy "

आप लोअरकेस के बजाय अपरकेस वर्णमाला का उपयोग करना चुन सकते हैं।

स्कोरिंग

यह , इसलिए सबसे छोटा कोड जीतता है!


1
स्विचिंग दिशाओं के संबंध में चरण 3 थोड़ा अस्पष्ट है। मुझे लगता है कि आपको ऐसा कुछ कहना चाहिए "यदि आप दाएं घूम रहे हैं और एक स्वर का सामना कर रहे हैं, तो उस चरित्र को एन्क्रिप्ट करें और फिर सही अनएन्क्रिप्टेड चरित्र पर जाएं और बाईं दिशा में एन्क्रिप्ट करना शुरू करें।" (यदि आपका यही मतलब है)। मुझे लगता है कि आपको यह भी स्पष्ट रूप से निर्दिष्ट करना चाहिए कि एन्क्रिप्ट किए गए वर्ण आउटपुट में उस क्रम में दिखाई देते हैं जिसमें वे एन्क्रिप्ट किए गए थे।
dylnan

@dylnan ने कहा कि
मनीष कुंडू

बस बाहर की जिज्ञासा - क्या आप डिक्रिप्शन प्रक्रिया का वर्णन कर सकते हैं? क्योंकि एन्क्रिप्शन फ़ंक्शन इसका स्वयं का उलटा नहीं है (जैसे ROT13 algo में)। इसलिए यदि हम एक एन्क्रिप्टेड डेटा को उसी सिफर प्रक्रिया में पास करते हैं - तो हमें मूल पाठ नहीं मिलेगा। धन्यवाद
Agnius Vasiliauskas

1
@AgniusVasiliauskas: ऐसा करने का एक तरीका यह होगा: एक ही चरित्र परिवर्तन लागू करें। 2 डिक्रिप्ट स्ट्रिंग्स रखें। बाएं से दाएं स्ट्रिंग पर लूप। पहले स्ट्रिंग को अपग्रेड करने और दूसरी बार जब आप एक स्वर को संभालते हैं, उसके बीच वैकल्पिक। अंत में तार मिलाएं।
एमिग्ना

3
इसके लिए जल्द ही एक डिक्रिप्शन चुनौती होगी, जिसमें मैं इस प्रक्रिया को समझाने की कोशिश करूंगा
मनीष कुंडू

जवाबों:


4

जावास्क्रिप्ट (Node.js) , 173 ... 166 156 ... 124 123 बाइट्स

-28 बाइट धन्यवाद अरनौल

f=([q,...s])=>q?(c="aeioubcdfghjklmpqrstvwxyz",t=c.search(q),q=="0"|+q?9-q:~t?c[(t<5?4:29)-t]:q)+f(~t&&t<5?s.reverse():s):s

इसे ऑनलाइन आज़माएं!

पहले पुनरावृति में Stringवसीयत को बदल दिया जाएगा Array, और बाद में पुनरावृत्तियों का उपयोग जारी रहेगा Array। देखा!

मूल दृष्टिकोण (166 बाइट्स):

f=(s,i=0,r=s.length,d=1,c="bcdfghjklmnpqrstvwxyz",v="aeiou")=>(d^=!!(t=~v.search(q=s[d?i:r])),q<"0"|q>"9"?c[20-c.search(q)]||v[5+t]||q:9-q)+(i<r-1?f(s,i+d,r-!d,d):"")

&कुछ नंबरों के लिए काम नहीं किया, लेकिन &&काम किया। धन्यवाद।
शायरु असकोतो

अरे हाँ, मुझे इसका अनुकूलन करने की कोई विधि नहीं मिली और आपने यह किया! धन्यवाद!
शायरु असकोतो

3
सभी अक्षरों के लिए एक ही स्ट्रिंग का उपयोग करके और कुछ और गोल्फिंग लगाने से 124 बाइट्स
अरण्युलड

वाह शानदार! मैं स्ट्रिंग्स के संयोजन के बारे में बिल्कुल नहीं सोचता था
Shieru Asakoto

q=="0"|+qवास्तव में 1 बाइट से छोटा है q>" "&&1/q
Arnauld

3

05AB1E , 22 बाइट्स

vćžN‡žM‡žh‡D?žMsåiR

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

v                        # for each char in input
 ć                       # extract the head of the current string (initially input)
  žN‡                   # transform consonants
      žM‡               # transofrm vowels
          žh‡           # transform numbers
              D?         # print a copy of the current char
                žMsåi    # if the current char is a vowel
                     R   # reverse the rest of the string

žhžMžN)UvćXJXíJ‡D?žMsåiRक्या मैं सुधार के लिए सोच रहा था, लेकिन XJXiJपर्याप्त कटौती नहीं कर सकता ।
मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: मेरे पास एक ऐसा विचार DJsíJथा जिसके साथ बहुत प्रभावी नहीं था।
15


1

जे , 132 बाइट्स

f=:3 :0
c=.(u:97+i.26)-.v=.'aeiou'
d=.u:48+i.10
g=.;"0|.
a=.''
while.*#y do.a=.a,{.y rplc(g c),(g d),g v
y=.|.^:({:a e.v)}.y
end.a
)

इसे ऑनलाइन आज़माएं!

इस समय एक क्रिया स्पष्ट है।

स्पष्टीकरण:

c=.(u:97+i.26) एक सूची बनाता है az

v=.'aeiou' स्वरों की सूची बनाता है

-. अक्षरों की सूची से स्वर निकालता है

d=.u:48+i.10 अंकों की एक सूची बनाता है

g=.;"0|. प्रतिस्थापन प्रतीकों के बॉक्सिंग जोड़े की एक सूची बनाने के लिए एक उपयोगिता क्रिया

   g d
┌─┬─┐
│0│9│
├─┼─┤
│1│8│
├─┼─┤
│2│7│
├─┼─┤
│3│6│
├─┼─┤
│4│5│
├─┼─┤
│5│4│
├─┼─┤
│6│3│
├─┼─┤
│7│2│
├─┼─┤
│8│1│
├─┼─┤
│9│0│
└─┴─┘

a=.'' परिणाम स्टोर करने के लिए एक सूची

while.*#y do.a=.a,{.y rplc(g c),(g d),g v जबकि सूची की लंबाई> 0 एक प्रतीक है, इसे प्रतिस्थापित करें और इसे परिणाम में जोड़ें

y=.|.^:({:a e.v)}.y सूची की शुरुआत से एक प्रतीक छोड़ें और यदि प्रतीक एक स्वर है, तो सूची को उल्टा कर दें

end.whileलूप को समाप्त करता है

a परिणाम देता है



0

रेटिना , 78 बाइट्स

T`dl`9-0uz-x\ow-vtis-pnem-j\hagfd-b
/[aeiou]/{*>0L`.*?[aeiou]
0`.*?[aeiou]

V`

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

T`dl`9-0uz-x\ow-vtis-pnem-j\hagfd-b

प्रत्येक पात्र को उसके समकक्ष स्वैप करें।

/[aeiou]/{

एक स्वर रहते हुए दोहराएं।

*>0L`.*?[aeiou]

पाठ को स्वर तक आउटपुट करें।

0`.*?[aeiou]

स्वर तक पाठ हटाएं।

V`

शेष पाठ को उलट दें। जब कोई स्वर नहीं बचे हैं, तो यह तब स्पष्ट रूप से आउटपुट होता है, हालांकि परीक्षण मामलों के प्रयोजनों के लिए, हेडर प्रत्येक पंक्ति के अंत में पाठ को आउटपुट करता है।


0

स्टेक्स , 24 बाइट्स

╥j•td╢Ä;Sµ*ûⁿvÉ╫î▓J o╩π╗

चलाओ

यहाँ एक ही कार्यक्रम के ascii प्रतिनिधित्व है।

VcGVdGVvGwB]qVvs#!Hv*c}cr\$|t

यह प्रत्येक वर्ण वर्ग का अनुवाद पहले करता है, फिर थोड़ी देर के लिए शुरू होता है। लूप में, यह अगले वर्ण को आउटपुट करता है, और सशर्त रूप से स्ट्रिंग के बाकी हिस्सों को उलट देता है यदि एक स्वर का सामना करना पड़ता है।

VcG                             Push lowercase consonants and jump to trailing }
   VdG                          Push digits and jump to trailing }
      VvG                       Push lowercase vowels and jump to trailing }
         wB]qVvs#!Hv*c          While; run this block until popped value is falsy
          B]                    Split first character off string 
            q                   Output with no newline; keep on the stack
             Vvs#               1 if letter is a vowel, 0 otherwise
                 !Hv            Not, Double, then Decrement
                                    -1 for vowels, 1 otherwise
                    *           Multiply string. -1 causes reversal       
                     c          Copy value to be popped as while condition
                      }         Jump target from above.  Return when done.
                       cr\$     Copy, reverse, zip, and flatten.
                           |t   Translate: use string as a character map
                                    for replacements
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.