शिफ्टिंग सीज़र शिफ़्ट

13

विवरण

सीज़र शिफ्ट एक बहुत ही सरल मोनोफैबेटिक सेफ़र है जहां वर्णमाला के बाद प्रत्येक अक्षर को एक के बाद एक बदल दिया जाता है। उदाहरण:

Hello world! -> IFMMP XPSME!

( IBSLR, EGUFV!वास्तविक चुनौती के लिए आउटपुट है, यह 1. द्वारा स्थानांतरण का एक उदाहरण था)

जैसा कि आप देख सकते हैं, रिक्ति और विराम चिह्न अनासक्त हैं। हालाँकि, संदेश का अनुमान लगाने से रोकने के लिए, सभी अक्षरों को बड़े अक्षरों में लिखा गया है। पत्रों को वापस शिफ्ट करने से, संदेश को डिक्रिप्ड, सुविधाजनक, लेकिन अन्य व्यक्तियों द्वारा समझने के लिए वास्तव में आसान हो गया, जिन्हें यह पता नहीं है कि संदेश का क्या मतलब है।

इसलिए, हम अपने सिफर के उन्नत रूप का उपयोग करके सीज़र की थोड़ी मदद करेंगे: सेल्फ शिफ्टिंग सीज़र शिफ्ट !

चुनौती

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

1. Compute letter differences of all adjacent letters: 
    1.1. Letter difference is computed like this:

         Position of 2nd letter in the alphabet
        -Position of 1st letter in the alphabet
        =======================================
                              Letter difference

    1.2. Example input: Hello
         H - e|e -  l|l  -  l|l  -  o
         7 - 5|5 - 12|12 - 12|12 - 15 Letter differences: 3; -7; 0; -3
            =3|   =-7|     =0|    =-3

2. Assign the letters continously a letter difference from the list,
   starting at the second letter and inverting the differences:
    2.1. 2nd letter: first difference, 3rd letter: second difference, etc.

    2.2. The first letter is assigned a 1.

    2.3. Example input: Hello with differences 3; -7; 0; -3

         Letter || Value
         =======||======
            H   ||   1
            E   ||  -3
            L   ||   7
            L   ||   0
            O   ||   3

3. Shift the letters by the value x they have been assigned:
    3.1. In case of a positive x, the letter is shifted x letters to the right.
    3.2. In case of a negative x, the letter is shifted |x| letters to the left.
    3.3. In case of x = 0, the letter is not shifted.

    3.4. If the shift would surpass the limits of the alphabet, it gets wrapped around
         Example: Y + Shift of 2 --> A

    3.5. Example input: See the table under 2.3.

                ||       || Shifted
         Letter || Value || Letter
         =======||=======||=========
            H   ||   1   ||    I
            E   ||  -3   ||    B     Program output:
            L   ||   7   ||    S     IBSLR
            L   ||   0   ||    L
            O   ||   3   ||    R

रिक्तियाँ और अन्य विशेष प्रतीक, जैसे विराम चिह्न इस प्रक्रिया में छोड़ दिए जाते हैं। यह गारंटी दी जाती है कि आपके प्रोग्राम को एक स्ट्रिंग दी जाएगी जिसमें केवल मुद्रण योग्य ASCII वर्ण होंगे। आपके फ़ंक्शन / प्रोग्राम का आउटपुट केवल ऊपरी मामले में होना चाहिए।

यह कोड-गोल्फ है , इसलिए मानक कमियां लागू होती हैं, और बाइट्स में सबसे कम जवाब जीत सकते हैं!

code-golf  string  cryptography 
— racer290
स्रोत
2
नहीं है E -3?
— लीक नून
3
क्या होगा अगर अक्षर अंतर अक्षर को वर्णमाला से बाहर लाता है? जैसे ZEN, उदाहरण के लिए। Z1 द्वारा स्थानांतरित किया गया है ... A? (एक साइड नोट के रूप में, 05AB1E उत्तर में बदल जाता Zहै A)
— श्री Xcoder
6
परीक्षण मामलों कृपया। इसके अलावा, कौन से अक्षर बिल्कुल छोड़ दिए गए हैं? और उनके छोड़े जाने का क्या मतलब है? क्या वे पूरी तरह से हटा दिए गए हैं, या क्या उन्हें आउटपुट में रहना चाहिए?
— लुइस मेन्डो
1
@Giuseppe परीक्षण के मामलों के लिए उत्कीर्ण उत्तरों को देखते हैं, वे ओपी द्वारा सही के रूप में मान्य किए गए हैं, मैं मान सकता हूं, या वे डाउनवोट होंगे।
— मैजिक ऑक्टोपस Urn
2
क्या आपके लिए RELIEFऔर RELIESसमान परिणाम के लिए दोनों तरह के शब्दों का मतलब था SRSFAG?
— एंडर्स कासोर्ग

जवाबों:

5

05AB1E , 28 27 24 बाइट्स

láÇ¥R`XIlvyaiAyk+Aèëy}u?

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

व्याख्या

l                          # convert input to lower case
 á                         # keep only letters
  ǥ                       # compute deltas of character codes
    R`                     # reverse and push separated to stack
      X                    # push 1
       Ilv                 # for each char y in lower case input
          yai              # if y is a letter
             Ayk           # get the index of y in the alphabet
                +          # add the next delta
                 Aè        # index into the alphabet with this
            ëy             # else push y
              }            # end if
            u?             # print as upper case
— Emigna
स्रोत
हम दोनों के IBSLR, EGUFV!लिए Hello, World!, यह सही है? क्या ओपी ने केवल उस उदाहरण को गड़बड़ कर दिया?
— मैजिक ऑक्टोपस Urn
1
@MagicOctopusUrn: शुरुआत में उनका उदाहरण दिखा रहा है कि क्या बदलाव है। यह सिर्फ 1 अक्षर से बदलता है इसलिए यह बहुत भ्रामक है।
— इमिग्ना जूल 18'17
4

पायथन 3 , 100 बाइट्स

b=0
for c in map(ord,input().upper()):
 if 64<c<91:b,c=c,(c+c-(b or~-c)-65)%26+65
 print(end=chr(c))

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

bअंतिम पत्र के ASCII कोड पर नज़र रखता है, या शुरू में शून्य है; सूत्र का c+c-(b or~-x)अर्थ है ASCII कोड वाला एक पत्र यदि गैर-शून्य है, और यदि शून्य है (बहुत पहले अक्षर के लिए) तो cस्थानांतरित हो जाता है ।c-bbc-(c-1) == +1b

bफिर कभी शून्य नहीं होगा, क्योंकि स्ट्रिंग को मुद्रण योग्य ASCII वर्णों से युक्त करने की गारंटी है ।

अंत में, 64<c<91जाँचता है कि cक्या एक अपरकेस ASCII पत्र है, और (…-65)%26+65सब कुछ वापस A-Zसीमा में लपेटता है ।

ओट्स ने एक बाइट को बचाया। धन्यवाद!

— लिन
स्रोत
— 18:४३ बजे
1

MATL , 27 बाइट्स

tXkt1Y2mXH)tlwdh+64-lY2w)H(

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

मुझे लगता है कि यह सबसे छोटा है जो मुझे मिल सकता है, लेकिन बहुत सी अलग-अलग किस्में हैं क्योंकि 'चर' (वहाँ 3 t(दोहराव) हैं, और 2 w(स्वैप) संचालन, क्लिपबोर्ड Hका उपयोग किया जाता है, और) फिर भी एक डुप्लिकेट अभी भी है 1Y2...)। अफसोस की बात है, मैं स्वचालित Mक्लिपबोर्ड के साथ बाइट्स नहीं बचा सका ।

कार्यक्रम के आधे से अधिक इसे अपरकेस बनाने और गैर-अल्फाबेटिक पात्रों की अनदेखी करने के लिए समर्पित है - बस सिफर 13 बाइट्स से अधिक नहीं है ( इसे ऑनलाइन आज़माएं! )

— Sanchises
स्रोत
1

पर्ल, 90 89

हालांकि गैर-कोडगुल्फ भाषाएं शायद ही कभी प्रतिस्पर्धी होती हैं, हम 100 से नीचे जा सकते हैं;)

@a=split//,<>;say uc(++$a[0]).join'',map{uc chr(2*ord($a[$_+1])-ord($a[$_])+!$_)}0..$#a-1

मैं यह ungolf करने का फैसला किया है:

@a = split//,<>; STDIN से इनपुट लेता है, @ में चरित्र सूची (newline के साथ!) संग्रहीत करता है।

say uc(++$a[0])आउटपुट अपरकेस पहला अक्षर 1. द्वारा स्थानांतरित किया गया है। यदि आप किसी उपसर्ग ++ का उपयोग करते हैं तो आप पर्ल में एक पत्र बढ़ा सकते हैं। यह एक म्यूटेंट टो है।

2*ord($a[$_+1])-ord($a[$_])+!$_हमें x पर वर्ण लेने के लिए कहा जाता है, और अंतर + (x- (x-1)) जोड़ते हैं। खैर यह 2x है - (एक्स -1)। हालाँकि: मैंने पहला अक्षर बदल दिया है! इसलिए मैंने उस त्रुटि को ठीक कर लिया है, इसलिए +!$_, जो स्थिति 0 पर एक बहुत अधिक घटाए जाने के लिए सही होगी (केवल निर्णय! $ _ अपरिभाषित नहीं है)। फिर हमें uc chrगणना किए गए ASCII मान से एक बड़ा अक्षर प्राप्त करना है।

map{ ... } $#a-2- $#aअंतिम सरणी तत्व तक पहुंचने की स्थिति है। चूंकि मैं जो चाहता हूं उसे जोड़ रहा हूं $#a-1, लेकिन क्योंकि इनपुट से न्यूलाइन को अनदेखा करने की आवश्यकता है, यह है $#a-2।

यह पहले अक्षर के साथ सम्‍मिलित है, और हम कर रहे हैं :)

— bytepusher
स्रोत
ऐसा लगता है कि कुछ समस्याएँ हैं जो ऑफ़सेट के साथ काम करती हैं जो वर्णमाला के चारों ओर लपेटती हैं और गैर-अक्षर वर्णों के साथ होती हैं। इसे ऑनलाइन आज़माएं!
— Xcali
1

पर्ल 5 -F , 73 77 74 बाइट्स

/\w/&&($_=chr 65+(2*($n=ord uc)-65-($!||-1+ord uc))%26)&($!=$n)for@F;say@F

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

— Xcali
स्रोत
यह गैर-पत्रों को पूरी तरह से छोड़ देता है; यह सिर्फ उन्हें परिवर्तित नहीं करता है। मुझे लगता है कि Hello, World!परिणाम में होना चाहिए IBSLR, EGUFV!, नहीं IBSLR, XGUFV!।
— टाइटस
आप सही हे। पिछले पत्र को संरक्षित करने के लिए इसे 4 और बाइट्स के साथ तय किया।
— Xcali
1

PHP, 106 98 बाइट्स

बहुत बुरा है कि एक ... अगर सिर्फ base_convertइतना लंबा नहीं था (या ctype_alpha) ...
लेकिन मैं इसे 100 से कम कर दिया। संतुष्ट।

for(;$a=ord($c=$argn[$i++]);print ctype_alpha($c)?chr(65+($p?(25-$p+2*$p=$a)%26:$p=$a)):$c)$a&=31;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

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