एक VIC सिफर एनकोडर लिखें

18

VIC सिफर सबसे जटिल पेंसिल और कागज सिफर कभी तैयार की है। 1950 के दशक में सोवियत जासूस रीनो हैहलेन द्वारा प्रयुक्त, "VICTOR" नाम से कोडित, इसका मुख्य सिद्धांत ओफ़्फ़्यूशन के माध्यम से सुरक्षा है; एक बहुत कहानियो की।

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

VIC सिफर एन्कोडिंग

तैयारी

आपको पाँच इनपुट की आवश्यकता होगी:

  • मैदानी संदेश
  • एक छोटा कीवर्ड या वाक्यांश जिसमें आपकी भाषा के सबसे सामान्य अक्षर हैं
  • एक प्रमुख वाक्यांश, जैसे कि एक उद्धरण या गीत से एक पंक्ति (कम से कम 20 अक्षर)
  • एक तारीख (या एक अन्य संख्या जो छह अंकों या अधिक है)
  • एक व्यक्तिगत एजेंट संख्या

व्यवहार में, इन अंतिम चार को पहले से ही प्रेषक और प्राप्तकर्ता द्वारा सहमत होना चाहिए, जिसमें यह भी शामिल है कि प्रेषक या प्राप्तकर्ता का एजेंट नंबर एन्कोडिंग में उपयोग किया जाता है या नहीं।

मेरा उदाहरण संदेश होगा: We are discovered. Take what you can. Burn everything else. Move to Safehouse Foxtrot 3.

हम अंग्रेजी में एन्कोडिंग करेंगे (हालाँकि आप जो भी भाषा और वर्णमाला पसंद करते हैं उसका उपयोग कर सकते हैं) और अंग्रेजी वर्णमाला में सबसे आम अक्षर हैं A, E, I, N, O, R, S, T। मैं कीवर्ड का उपयोग करूँगा SENATORI।

मेरा मुख्य वाक्यांश रिचर्ड फेनमैन का एक उद्धरण है: "पहला सिद्धांत यह है कि आपको खुद को मूर्ख नहीं बनाना चाहिए - और आप मूर्ख बनाने वाले सबसे आसान व्यक्ति हैं।"

दिनांक के रूप में, मैं 31 जुलाई, 2016 (प्रारूप में) का उपयोग करूँगा 3172016 ) का , जिस दिन यह विवरण मैंने लिखा था।

मैंने अपने लिए जो व्यक्तिगत नंबर चुना है, वह है 9 ।

चरणों का सारांश

  1. निम्नलिखित चरणों में उपयोग के लिए मध्यवर्ती कुंजियों को वितरित करें।
  2. स्ट्रैडलिंग चेकबोर्ड का निर्माण और आवेदन करें।
  3. पहले ट्रांसपोज़न टेबल का निर्माण और आवेदन करें।
  4. दूसरे (विघटित) ट्रांसपोज़ेशन टेबल का निर्माण और आवेदन करें।
  5. संदेश संकेतक समूह को सम्मिलित करके संदेश को अंतिम रूप दें।

Submechanisms

मामले के मांस में उतरने से पहले दो और बातें बताई गई हैं: श्रृंखला जोड़ और अनुक्रमिक की प्रक्रियाएँ।

चेन जोड़, जिसे एक लैग्ड फाइबोनैचि जनरेटर के रूप में भी जाना जाता है, एक शुरुआती अंक अनुक्रम लेकर काम करता है, पहले दो अंकों को बिना ले जाने (उन्हें फिर mod 10जोड़कर) जोड़कर परिणाम को अंतिम रूप देता है। उदाहरण के लिए:

79081
7 + 9 = 6

790816
9 + 0 = 9

7908169
0 + 8 = 8

79081698
8 + 1 = 9

790816989
1 + 6 = 7

7908169897
... and so on

अनुक्रमिकता अनिवार्य रूप से अक्षरों या अंकों का एक क्रम ले रही है और उन्हें अपने वर्णमाला / संख्यात्मक क्रम से लेबल कर रही है। डुप्लिकेट को बाएं से दाएं लेबल किया जाता है। उदाहरण के लिए:

E X A M P L E
    0           # A
1   0       2   # Es
1   0     3 2   # L
1   0 4   3 2   # M
1   0 4 5 3 2   # P
1 6 0 4 5 3 2   # X

3  3  0  5  8  4  2  0  4  7  5  4  8  1
      0              1                     # 0s
      0              1                 2   # 1
      0           3  1                 2   # 2
4  5  0           3  1                 2   # 3s
4  5  0        6  3  1  7        8     2   # 4s
4  5  0  9     6  3  1  7    10  8     2   # 5s
4  5  0  9     6  3  1  7 11 10  8     2   # 7
4  5  0  9 12  6  3  1  7 11 10  8 13  2   # 8s

मैं यहां जीरो-इंडेक्सिंग का उपयोग करता हूं, लेकिन इंडेक्स आपको पसंद है।

1. इंटरमीडिएट की

कुंजी वाक्यांश के पहले 20 अक्षरों को 10 के दो समूहों में विभाजित करें और प्रत्येक को अलग-अलग अनुक्रमित करें, जिसे हम कॉल करेंगे S1और S2।

    THEFIRSTPR
S1: 8201357946

    INCIPLEIST
S2: 2603751489

एक यादृच्छिक 5-अंकीय संदेश पहचानकर्ता चुनें, M(यदि आप चाहें तो यह इनपुट में से एक हो सकता है):

M = 47921

घटाएँ, उधार लेने के बिना (घटाना mod 10), कुंजी तारीख के पहले पांच अंक 3172016से M:

M      47921
date - 31720
     = 16201

जब तक आपके पास दस अंक न हों, तब तक परिणाम जोड़ें:

1620178218

प्राप्त करने के लिए, S1ले या बिना, इन अंकों को जोड़ें :mod 10G

     1620178218
S1 + 8201357946
G  = 9821425154

ऊपर S2, अनुक्रम 0123456789 लिखें। अनुक्रम 0123456789 में प्रत्येक अंक का पता लगाएँ Gऔर इसे नीचे सीधे अंक के साथ बदलें S2। परिणाम है T।

   0123456789
S2 2603751489

G  9821425154
T  9806705657

T60 अंकों तक विस्तार करने के लिए श्रृंखला जोड़ का उपयोग करें ।

9806705657

becomes

980670565778637511245490262369939288595822106344304316978734

ये पिछले 50 अंक, प्रत्येक दस अंकों की पांच पंक्तियों में, Uब्लॉक बनाते हैं ।

T  9806705657
U  7863751124
   5490262369
   9392885958
   2210634430
   4316978734

Uब्लॉक के अंतिम दो गैर-बराबर अंक व्यक्तिगत रूप से एजेंट की व्यक्तिगत संख्या में दो बदलावों की चौड़ाई देने के लिए जोड़े जाते हैं, pऔरq ।

9 + 3 = 12 (पी, पहला ट्रांसपोज़ेशन चौड़ाई) 9 + 4 = 13 (क्यू, दूसरा ट्रांसपोज़ेशन चौड़ाई)

खंड Tके कॉलम को कॉपी करने के लिए Uऊपर से नीचे, अंकों की एक नई पंक्ति में, अनुक्रमित और उपयोग करें V।

T     9806705657
seqT  9804612537

U     7863751124
      5490262369
      9392885958
      2210634430
      4316978734

V     69911 56837 12548 26533 30206 13947 72869 49804 84323 75924

पहले pअंक के लिए कुंजी प्राप्त करने के लिए पहले अंकों को अनुक्रमिक करें K1, और qदूसरे के लिए कुंजी के लिए निम्नलिखित अंक K2।

First 12  6  9  9  1  1  5  6  8  3  7  1  2
K1        6 10 11  0  1  5  7  9  4  8  2  3

Next 13   5  4  8  2  6  5  3  3  3  0  2  0  6
K2        8  7 12  2 10  9  4  5  6  0  3  1 11

अंत में, Uप्राप्त करने के लिए ब्लॉक की अंतिम पंक्ति को अनुक्रमिक करें C, स्ट्रैडलिंग चेकबोर्ड के लिए कॉलम हेडर:

U5  4316978734
C   3105968724

2. तेजस्वी चेकरबोर्ड

पहले, मैं अपना उदाहरण बिसात दे दूंगा फिर उस तरीके से इसे बनाने के सिद्धांतों की व्याख्या करूँगा:

  3 1 0 5 9 6 8 7 2 4
  S E N A T O R I
2 B D G J L P U W Y .
4 C F H K M Q V X Z #

अक्षरों की पहली पंक्ति हमारा छोटा कीवर्ड है SENATORI। आपका कीवर्ड डुप्लिकेट के बिना कोई भी स्ट्रिंग हो सकता है, लेकिन चूंकि यह आपके चेकबोर्ड की शीर्ष पंक्ति को परिभाषित करता है, इसलिए बुद्धिमानी से चुनें। कीवर्ड के ऊपर है C, और अन्य पंक्तियाँ आपके वर्णमाला के बाकी हैं जो भी आप चुनते हैं। मेरे मामले में, मैंने बाकी लैटिन वर्णमाला, विराम चिह्न .और सीमांकन संख्याओं के लिए एक निशान के साथ बिसात भर दी #। अनिवार्य रूप से, बिसात एक फैंसी स्थानापन्न सिफर है। उदाहरण के लिए, "ई" के साथ प्रतिस्थापित किया जाएगा 1, और "डब्ल्यू" के साथ प्रतिस्थापित किया जाएगा27 ।

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

We are discovered. Take what you can. Burn everything else. Move to Safehouse Foxtrot 3.

हो जाता है

HING ELSE. MOVE TO SAFEHOUSE FOXTROT#3#.. WE ARE
DISCOVERED. TAKE WHAT YOU CAN. BURN EVERYT

हम चेकबोर्ड के साथ सांकेतिक शब्दों में बदलना, हमें दे:

407020 1293124 496481 96 354114062831 416479869443442424 271 581 
2173436481812124 95451 274059 22628 435024 232880 14818229

यदि संदेश की लंबाई 5 से विभाज्य नहीं है, तो हम संदेश को पैड करने के लिए कुछ अशक्त वर्ण जोड़ते हैं। हमारा संदेश 109 अंक लंबा है, इसलिए मैं एक नल जोड़ूंगा: "4"।

40702 01293 12449 64819 63541 14062 83141 64798 69443 44242 42715
81217 34364 81812 12495 45127 40592 26284 35024 23288 01481 82294

नोट: चूँकि मेरे उदाहरण संदेश में संख्याएँ नहीं हैं, इसलिए मैं यहाँ कहूँगा कि आप इसका उल्लेख कर सकते हैं, जैसा कि यहाँ बताया #3#गया 44344है।

3. पहला ट्रांसपोजिशन

ट्रांसपोज़ेशन टेबल K1(इंटरमीडिएट कीज़ सेक्शन से) लिखकर उसके बाद पिछले स्टेप से एन्कोड किए गए मैसेज को उसी लंबाई की पंक्तियों में कुंजी के नीचे बनाएँ :

K1   6 10 11  0  1  5  7  9  4  8  2  3

     4  0  7  0  2  0  1  2  9  3  1  2
     4  4  9  6  4  8  1  9  6  3  5  4
     1  1  4  0  6  2  8  3  1  4  1  6
     4  7  9  8  6  9  4  4  3  4  4  2
     4  2  4  2  7  1  5  8  1  2  1  7
     3  4  3  6  4  8  1  8  1  2  1  2
     4  9  5  4  5  1  2  7  4  0  5  9
     2  2  6  2  8  4  3  5  0  2  4  2
     3  2  8  8  0  1  4  8  1  8  2  2
     9  4

उनकी संख्या के क्रम में गिने हुए कॉलम लेना

060826428  246674580  151411542  246272922  961311401  082918141
4414434239 118451234  334422028  293488758  0417249224 794943568

4. दूसरा स्थानान्तरण

पहला वाष्पोत्सर्जन अपेक्षाकृत सरल था। हालांकि, यह एक बाधित व्यवधान है। विघटन पैटर्न तालिका की चौड़ाई और कुंजी द्वारा निर्धारित किया जाता है। हमारे उदाहरण में, हमारे पास 110 अंक और 13 कॉलम हैं, जिसका अर्थ है कि हमारी 8 पूर्ण पंक्तियाँ और 6 बचे हुए हैं। हम पहली पंक्ति में भरना शुरू करते हैं, लेकिन कॉलम 0 पर रुकते हैं, और निम्नानुसार जारी रखते हैं:

K2   8  7 12  2 10  9  4  5  6  0  3  1 11

     0  6  0  8  2  6  4  2  8              stop at 0
     2  4  6  6  7  4  5  8  0  1           continue in a triangle pattern
     5  1  4  1  1  5  4  2  2  4  6
     2  7  2  9  2  2  9  6  1  3  1  1
     4  0  1  0  8  2  9  1  8  1  4  1  4  until the end
     4  1  4  4  3  4  2  3  9  1  1        restart and stop at 1
     8  4  5  1  2  3  4  3  3  4  4  2
     2  0  2  8  2  9  3  4  8  8  7  5  8
     0  4  1                                restart and stop at 2

फिर हम शेष अंकों के साथ अंतिम कुछ रिक्त स्थान भरते हैं।

K2   8  7 12  2 10  9  4  5  6  0  3  1 11

     0  6  0  8  2  6  4  2  8  7  2  4  9
     2  4  6  6  7  4  5  8  0  1  2  2  4
     5  1  4  1  1  5  4  2  2  4  6  7  9
     2  7  2  9  2  2  9  6  1  3  1  1  4
     4  0  1  0  8  2  9  1  8  1  4  1  4
     4  1  4  4  3  4  2  3  9  1  1  9  4
     8  4  5  1  2  3  4  3  3  4  4  2  3
     2  0  2  8  2  9  3  4  8  8  7  5  8
     0  4  1  5  6  8

अब, हम उसी तरह से कॉलम को पढ़ते हैं जिस तरह से हमने पहले ट्रांसपोजेशन के लिए किया था।

71431148  42711925  861904185 22614147  45499243  28261334  80218938
641701404 025244820 645224398 271283226 94944438  064214521

और 5 अंकों के समूहों में सब कुछ विभाजित करें:

71431 14842 71192 58619 04185 22614 14745 49924 32826 13348 02189
38641 70140 40252 44820 64522 43982 71283 22694 94443 80642 14521

5. संदेश को अंतिम रूप दें

अंतिम चरण हमारे यादृच्छिक संदेश पहचानकर्ता 47921को संदेश में ही सम्मिलित करना है। कुंजी तिथि का अंतिम अंक 6इंगित करता है कि समूह की दूरी अंत से होनी चाहिए।

71431 14842 71192 58619 04185 22614 14745 49924 32826 13348 02189 38641
70140 40252 44820 64522 43982 47921 71283 22694 94443 80642 14521

इस चुनौती के लिए नोट्स

  • आपको न्यूनतम पांच इनपुट दिए गए हैं: संदेश, पत्र कीवर्ड, कुंजी वाक्यांश, दिनांक और एक व्यक्तिगत संख्या। आप दो अतिरिक्त इनपुट शामिल कर सकते हैं: यादृच्छिक संदेश पहचानकर्ता और संदेश को पैड करने के लिए आवश्यक नल, या आपका फ़ंक्शन अपने आप कुछ यादृच्छिक संख्या उत्पन्न कर सकता है।
  • आप मान सकते हैं कि सभी इनपुट मान्य हैं, अंकों और अक्षरों की सही संख्या के साथ (5-अंक संदेश पहचानकर्ता, कुंजी वाक्यांश के लिए कम से कम 20 अंक, और इसी तरह)। आप यह मान सकते हैं कि आपके तार (संदेश और कीवर्ड) में पहले से ही उन सभी को छोड़कर सभी विराम चिह्नों और रिक्त स्थान हैं, जिन्हें आप अपने संस्करण में अनुमति देते हैं, और संख्याएँ पहले से ही संख्या चिह्नों के साथ सीमांकित हैं।
  • पहले कीवर्ड में डुप्लिकेट अक्षर नहीं होने चाहिए, और आपके कोड में, आप मान सकते हैं कि इसमें कभी भी डुप्लिकेट अक्षर नहीं हैं।
  • आप जिस भाषा में एनकोड करने के लिए उपयोग करते हैं वह मायने नहीं रखती है, जब तक कि भाषा preexisting है, वर्णमाला preexisting है, और आप निर्दिष्ट करते हैं कि आप अपने उत्तर में किस भाषा का उपयोग करते हैं।
  • आप जिस भी वर्णमाला को अपने तेजस्वी चेकरबोर्ड के लिए नियोजित करते हैं, आप चेकरबोर्ड को बाहर पैड करने के लिए प्रतीकों को जोड़ या हटा सकते हैं। निर्दिष्ट करें कि आप उन प्रतीकों का क्या उपयोग करते हैं (उदाहरण के लिए, विराम चिह्न, एक अलग "संदेश शुरू" प्रतीक, सामान्य शब्दों के लिए प्रतीक)। आप नंबर साइन को पूरी तरह से छोड़ सकते हैं और नंबर को स्पेल कर सकते हैं या चेकरबोर्ड में प्रत्येक अंक को शामिल कर सकते हैं, स्लॉट का उपयोग करके जहां नंबर साइन कुछ और के लिए था। कृपया निर्दिष्ट करें कि आपने अपने उत्तर में किस चेकबोर्ड का उपयोग किया है।
  • आउटपुट या तो अंतरिक्ष-पृथक पांच-अंकीय समूहों, पांच-अंकीय पूर्णांकों की सूची या कुछ इसी तरह का होना चाहिए।
  • मैंने शून्य-अनुक्रमण का उपयोग किया और 0123456789अपने उदाहरण में। 1234567890जब तक आप निर्दिष्ट करते हैं कि आप अपने उत्तर में 1-अनुक्रमण और , या किसी अन्य प्रणाली का उपयोग कर सकते हैं।

यहाँ Ideone पर एक उदाहरण कार्यान्वयन है ।

यह एक लंबी पोस्ट है और मैंने इसे ज्यादातर हाथों से लिखा है, इसलिए यदि इस पोस्ट में कोई भी भ्रमित करने वाले भाग हैं या मेरी गिनती और ट्रांसपोज़िंग में त्रुटियां हैं, तो कृपया मुझे बताएं। गुड लक और गुड गोल्फिंग!

code-golf  cryptography 
— Sherlock9
स्रोत
1
adding the first two digits without addingक्या आप ले जाने का मतलब है?
— isaacg
@ आइसाकग हां, मैंने किया। संपादित।
— शर्लक
क्या आप इस बात पर स्पष्टीकरण दे सकते हैं कि आप क्या मतलब है without borrowingऔर without carrying? क्या आपका मतलब है जोड़ने और घटाना mod 10, यानी (6+7) mod 10 = 3और (6-8) mod 10 = 8?
— आर। काप
@ R.Kap हाँ, मुझे स्पष्ट करने दें।
— शर्लक
हम करते है हदबंदी संख्या के लिए?
— आर। कप

जवाबों:

10

पायथन 3 , 1423 1348 1324 1316 1300 1286 1250 1249 1209 1206 1204 बाइट्स

यह निश्चित रूप से सबसे लंबा गोल्फ है जो मैंने कभी किया है, और एकमात्र गोल्फ है जहां मैं एक-चरित्र चर नामों से बाहर चलने के बारे में गंभीर रूप से चिंतित था। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

मैं अपर वर्णों के साथ अपरकेस लैटिन वर्णमाला के साथ एन्कोडिंग कर रहा हूं .और #0-इंडेक्सिंग का उपयोग कर रहा हूं और 0123456789जब परिवर्तित gहो रहा हूं t। मेरा चेकबोर्ड निम्नलिखित उदाहरण के समान प्रारूप में है:

  2 9 7 4 5 8 3 1 0 6    # C
  S E N A T O R I        # keyword
0 B D G J L P U W Y .    # remaining alphabet arranged in columns
6 C F H K M Q V X Z #    # . and # at the end

संपादित करें: -63 बाइट्स टू-लेक चर के साथ अक्सर उपयोग किए जाने वाले कुछ कार्यों को छोटा करने के सुझाव के लिए धन्यवाद। -12 बाइट्स बनाने सेa, g, t अधिक कॉम्पैक्ट ।

संपादित करें: -24 बाइट मध्यवर्ती कुंजी के लिए चर नाम हटाकर बनाने से जो केवल एक बार उपयोग किया जाता है, अर्थात् a, g, s, S, k, K।

संपादित करें: -74 समेकन से बाइट्स H(), T() and C()।

संपादित करें: -1 बाइट का धन्यवाद निक ए के लिए उनके बदलने के सुझाव के ord(s[i])+ord(s[i+1])लिए sum(map(ord,s[i:i+2]))। 2 +=[a]कॉल को बदलने से -2 बाइट्स +=a,। -13 बाइट्स को बदलने से कि कैसे G()न्यूनतम का सूचकांक मिला s। से बदलने के y=(y+1)%vलिए -2 बाइट्स y=-~y%v। -15 बाइट्स को असाइन k.index()करने से K। -4 बाइट्स को असाइन 10करने से W। -5 बाइट्स अंदर से असाइन 1-I(d[-1])करने से । -3 बाइट्स मुख्य लूप की पुनर्लेखन से । पुनर्गठन से -2 बाइट्स ।XVC()T()

I=int;L=list;E=len;R=range;B=str;J=''.join;W=10
def H(s,e):
 for i in R(e-E(s)):s+=chr(48+sum(map(ord,s[i:i+2]))%32%W)
 return s
def Q(s):
 r=[0]*E(s);s=L(s)
 for z in R(E(s)):b=s.index(min(s));r[b]=z;s[b]="~"
 return r
def T(x,k,d=0):
 u=E(x);v=E(k);g=R(v);K=k.index;n=u//v+1;w=[];e=r=y=0;i=K(y);c=[]
 if d:
  while r<n:
   if r>n-1:i=min(i,(u%v or v))
   w+=L(x[e:e+i]),;e+=i;i+=1;r+=1
   if i>v:y=-~y%v;i=K(y)
  r=y=0;i=v-K(y)
  while r<n:
   w[r]+=L(x[e:e+i]);e+=i;i-=1;r+=1
   if i<1:y+=1;i+=v-K(y);r+=1
  w[-1]+=['']*(v-E(w[-1]))
  for j in g:c+=J(z[j]for z in w),
 else:c=[x[i::v]for i in g]
 s=[0]*v
 for f in g:s[k[f]]=c[f]
 return J(s)
def C(m,s,w,n):
 t={".":s[-2:],"#":s[-1]*2};j=z=0
 for x in R(26):
  v=chr(x+65)
  if v in w:t[v]=s[w.index(v)]
  else:t[v]=s[z-2]+s[j];j+=z;z=-~z%2
 r=J(i.isdigit()and i or t[i]for i in m)
 return r+n[:-E(r)%5]
def V(m,w,P,d,A,M,n):X=1-I(d[-1]);t=J(B(Q(P[W:20])[I(J(B((I(H(J(B((I(M[i])-I(d[i]))%W)for i in R(5)),W)[i])+I(Q(P[:W])[i]))%W)for i in R(W))[i])])for i in R(W));u=H(t,60)[W:];p=A+I(u[-2]);v=T(u,Q(t));z=T(T(C(m,J(B(i)for i in Q(u[40:])),w,n),Q(v[:p])),Q(v[p:p+A+I(u[-1])]),1);e=[z[5*i:5*-~i]for i in R(-(-E(z)//5))];return' '.join(e[:X]+[M]+e[X:])

Ungolfing:

def chain_add(seq, end):
    for i in range(end - len(seq)):
        seq += chr(48+sum(map(ord,seq[i:i+2]))%32%10)
    return seq

def sequent(seq):
    res = [0]*len(seq)
    seq = list(seq)
    for z in range(len(seq)):
        b = seq.index(min(seq))
        res[b] = z
        seq[b] = "~"
    return res

def transpose(text, keys, disrupt=False):
    if disrupt:
        num_rows = len(text) // len(keys) + 1
        len_last = len(text) % len(keys)
        if len_last == 0:
            len_last = len(keys)
        d_rows = []
        text_index = 0
        current_row = 0
        stop_key = 0
        stop_index = keys.index(stop_key)
        while current_row < num_rows:
            if current_row > num_rows-1:
                stop_index = min(stop_index, len_last)
            d_rows += [list(text[text_index:text_index+stop_index])]
            text_index += stop_index
            stop_index += 1
            if stop_index>len(keys):
                stop_key = (stop_key+1) % len(keys)
                stop_index = keys.index(stop_key)
            current_row += 1
        current_row = 0
        stop_key = 0
        stop_len = len(keys) - keys.index(stop_key)
        while current_row < num_rows:
            d_rows[current_row] += list(text[text_index:text_index+stop_len])
            text_index += stop_len
            stop_len -= 1
            if stop_len < 1:
                stop_key += 1
                stop_len = len(keys) - keys.index(stop_key)
                current_row += 1
            current_row += 1
        d_rows[-1] += ['']*(len(keys)-len(d_rows[-1]))
        columns = []
        for j in range(len(keys)):
            columns += [''.join(i[j]for i in d_rows)]
    else:
        columns = ['']*len(keys)
        for t in range(len(text)):
            columns[t%len(keys)] += text[t]
    res = [0]*len(keys)
    for index in range(len(keys)):
        res[keys[index]] = columns[index]
    return''.join(res)

def checkerboard(message, seq, word, null):
    trans = {".":seq[-2:], "#":seq[-1]*2};res='';j=z=0
    for x in range(26):
        v = chr(x + 65)
        if v in word:
            trans[v] = seq[word.index(v)]
        else:
            trans[v] = seq[z-2] + seq[j]
            j += z
            z = (z+1) % 2
    for i in message:
        if i.isdigit():
            res += i
        else:
            res += trans[i]
    return res + null[:-len(res)%5]

def vic_cipher(message, keyword, phrase, date, agent, m_id, null):
    s1 = sequent(phrase[:10])
    s2 = sequent(phrase[10:20])
    a = ''.join(str((int(m_id[i])-int(date[i]))%10) for i in range(5))
    g = ''.join(str((int(a[i])+int(s1[i]))%10) for i in range(10))
    t = ''.join(str(s2[int(g[i])]) for i in range(10))
    u = chain_add(t,60)[10:]
    p = agent+int(u[-2])
    q = agent+int(u[-1])
    seqT = sequent(t)
    v = transpose(u,seqT)
    k1 = sequent(v[:p])
    k2 = sequent(v[p:p+q])
    c = ''.join(str(i)for i in sequent(u[40:]))
    x = checkerboard(message,c,keyword,null)
    y = transpose(x,k1)
    z = transpose(y,k2,1)
    e = [z[5*i:5*(i+1)] for i in range(-(-len(z)//5))]
    X = 1-int(date[-1])
    return ' '.join(e[:X] + [m_id] + e[X:])
— Sherlock9
स्रोत
2
अजगर 3 चर, यूपीआई के रूप में यूनिकोड वर्णों की अनुमति देता है।
— पॉल
मेरा मानना ​​है कि 1 वर्ण ord(seq[i])+ord(seq[i+1])को sum(map(ord,seq[i:i+2]))सहेजना बदलना ।
3

सी, 2880 2769 2766 2762 2743 2741 2739 2699 2458 बाइट्स

#include<stdio.h>
#define m(x)malloc(x)
#define Y(x)strlen(x)
typedef int i;typedef char*c;c _(c A,i B,i D){if(D>=B){return A;}c C=m(Y(A)+2);sprintf(C,"%s%c",A,48+(A[D]+A[D+1]-96)%10);return _(C,B,D+1);}c l(c A){i J=Y(A);c P=m(J+2);for(i m=0;m<J;m++){P[m]=32;}for(i v=0;v<J;v++){char G;i R;for(i u=0;u<J;u++){R=u<1|A[u]<G?u:R;G=u<1|A[u]<G?A[u]:G;}P[R]=48+v;c V=m(J);for(i t=0;t<J;t++){V[t]=t!=R?A[t]:97;}A=V;}return P;}c S(c C,c N,c I,char U){srand(time(NULL));i M=Y(I);i O=Y(N);i R=rand()%M;c Q=m(M+1);for(i u=R;u<M;u++){Q[u-R]=I[u];}Q[M-R]=46;for(i H=0;H<R;H++){Q[H+M-R+1]=I[H];}c g=m(28);c V=m(28);strcat(V,C);sprintf(g,"%s%s",N,"BCDFGHJKLMPQUVWXYZ.#");i B=Y(N);for(i q=B;q<10;q++){for(i x=0;x<10;x++){char J[2]={C[q],C[x]};V[B]=48+atoi(J);B++;}}c w=m(M*2+4);for(i J=0;J<=M;J++){i K=0;for(i X=0;X<28;X++){if(Q[J]==g[X]){char F[3];sprintf(F,"%d",V[X]-48);strcat(w,F);K=1;}}if(K<1){w[Y(w)]=Q[J];}}i f=Y(w);if(f%5>0){c P=m(5-f%5);for(i E=0;E<5-f%5;E++){P[E]=U;}strcat(w,P);}return w;}c a(c I,c U){i M=Y(I),K=Y(U);c T=m(M);i F=0;for(i b=0;b<K;b++){for(i y=0;y<K;y++){if(U[y]==48+b){for(i u=y;u<M;u+=K){T[F]=I[u];F++;}}}}return T;}c da(c I,c K){i e=Y(I),k=Y(K);c T=m(e);for(i y=0;y<e;y++){T[y]=32;}i F,P;F=P=0;for(i u=0;u<k;u++){for(i v=0;v<k;v++){T[F]=I[P];P++;F++;if(K[v+1]-48==u){for(i C=1;C<k-v;C++){F+=k-v-C;for(i E=0;E<=v+C;E++){if(F<e&P<e){T[F]=I[P];}F++;P++;}}break;}}if(F>e){break;}}i U=0;for(i g=0;g<e;g++){U=T[g]-48<10&-1<T[g]-48?U+1:U;}for(i j=U;j<e;j++){for(i x=0;x<e;x++){if(T[x]==32){T[x]=I[j];break;}}}return a(T,K);}En(c n,c m,c k,i d,c v,c s,char u){c S1,S2;S1=m(10);S2=m(10);for(i i=0;i<20;i++){if(i<10){S1[i]=k[i];}else{S2[i-10]=k[i];}}S1=l(S1);S2=l(S2);c M=m(5);for(i i=4;i>-1;i--){M[i]=48+(s[i]-v[i])%10;}c G=_(M,5,0);for(i y=0;y<10;y++){G[y]=48+(S1[y]+G[y]-96)%10;}c N="0123456789";c T=m(10);for(i q=0;q<10;q++){for(i t=0;t<10;t++){if(N[t]==G[q]){T[q]=S2[t];}}}c Z=_(T,50,0);c U=m(50);for(i h=0;h<50;h++){U[h]=Z[h+10];}i p,q;for(i b=49;b>10;b++){if(U[b]!=U[b-1]){q=d+U[b]-48;p=d+U[b-1]-48;break;}}c V=m(50);i Ct=0;for(i j=0;j<10;j++){for(i o=0;o<10;o++){if(l(T)[o]==48+j){for(i x=o;x<o+41;x+=10){V[Ct]=U[x];Ct+=1;}}}}c K1=m(p);c K2=m(q);for(i D=0;D<p+q;D++){if(D<p){K1[D]=V[D];}else{K2[D-p]=V[D];}}K1=l(K1);K2=l(K2);c C=m(10);for(i b=40;b<50;b++){C[b-40]=U[b];}C=l(C);c t=da(a(S(C,m,n,u),K1),K2);i O=0;for(i B=0;B<Y(t)/5+1;B++){if(B==Y(t)/5-v[Y(v)-1]+49){printf("%s ",s);}else{for(i J=O;J<O+5;J++){printf("%c",t[J]);}printf(" ");O+=5;}}}

हे भगवान। यह सबसे लंबे समय तक कार्यक्रम मैं है कभी गोल्फ था। यह पहला भी है जिस पर मैं वास्तव में वैश्विक दायरे के लिए एकल-वर्ण चर नामों से बाहर चला गया था और इसलिए कुछ 2 चरित्र वाले (इस तथ्य को स्पष्ट करने के लिए आगे बढ़ना था कि मैं स्पष्ट रूप से चर नहीं कर सकता हूं)। इसलिए गोल्फ टिप्स की बहुत सराहना की जाती है।

Ungolfed

बिना किसी चेतावनी के संकलन, गोल्फ संस्करण के विपरीत। गोल्फ संस्करण के लिए किए गए मामूली बदलाव इस असंगत संस्करण में परिलक्षित नहीं होंगे।

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

char*Chain_Add(char*String,int End,int Start){
  if(Start>=End){return String;}
  char*C=malloc(strlen(String)+2);
  sprintf(C,"%s%c",String,'0'+(((String[Start]-'0')+(String[Start+1]-'0'))%10));
  return Chain_Add(C,End,Start+1);
}

char*Sequent(char*String){
  int J=strlen(String);
  char*P=malloc(J+2);
  for(int m=0;m<J;m++){
    P[m]=' ';
  }
  for(int v=0;v<J;v++){
    char G;
    int R;
    for(int u=0;u<J;u++){
      R=(u<1||String[u]<G)?u:R;
      G=(u<1||String[u]<G)?String[u]:G;
    }
    P[R]='0'+v;
    char*V=malloc(J);
    for(int t=0;t<J;t++){
      if(t!=R){
    V[t]=String[t];
      }
      else{
    V[t]='a';
      }
    }
    String=V;
  }
  return P;
}

char*Straddling_Checkerboard(char*C,char*Key,char*Message,char null){
  srand(time(NULL));
  int Msg_Len=strlen(Message);
  int Key_Len=strlen(Key);
  int R=rand()%Msg_Len;
  char*Q=malloc(Msg_Len+1);
  for(int u=R;u<Msg_Len;u++){
    Q[u-R]=Message[u];
  }
  Q[Msg_Len-R]='.';
  for(int H=0;H<R;H++){
    Q[H+Msg_Len-R+1]=Message[H];
  }
  char*Alphabet=malloc(26);
  for(int W=0;W<26;W++){
    Alphabet[W]='A'+W;
  }
  int q=0;
  char*e=malloc(Key_Len);
  for(int z=0;z<Key_Len;z++){
    if(strchr(e,Key[z])!=NULL){
      q++;
    }
    else{
      e[z-q]=Key[z];
    }
  }
  int r=0;
  for(int h=0;h<26;h++){
    if(strchr(e,Alphabet[h-r])!=NULL){
      for(int X=h-r;X<26;X++){
    Alphabet[X]=Alphabet[X+1];
      }
      r++;
    }
  }
  char*Checkerboard=malloc(28);
  for(int i=0;i<26;i++){
    if(i<strlen(e)){
      Checkerboard[i]=e[i];
    }
    else{
      Checkerboard[i]=Alphabet[i-strlen(e)];
    }
  }
  Checkerboard[26]='.';
  Checkerboard[27]='#';
  char*Values=malloc(28);
  strcat(Values,C);
  int B=strlen(e);
  for(int q=B;q<10;q++){
    for(int x=0;x<10;x++){
      char J[2]={C[q],C[x]};
      Values[B]='0'+atoi(J);
      B++;
    }
  }
  char*Encoded=malloc(Msg_Len*2+4);
  for(int J=0;J<=Msg_Len;J++){
    int K=0;
    for(int X=0;X<28;X++){
      if(Q[J]==Checkerboard[X]){
    char F[3];
    sprintf(F,"%d",Values[X]-'0');
    strcat(Encoded,F);
    //printf("F = %s while Q[J] = %c and Checkerboard[X] = %c and Encoded = %s\n",F,Q[J],Checkerboard[X],Encoded);
    K=1;
      } 
    }
    if(K<1){
      Encoded[strlen(Encoded)]=Q[J];
    }
  }
  int Encded_Len=strlen(Encoded);
  if(Encded_Len%5>0){
    char*P=malloc(5-Encded_Len%5);
    for(int E=0;E<5-Encded_Len%5;E++){
      P[E]=null;
    }
  strcat(Encoded,P);
  }
  return Encoded;
}

char*Transpose(char*Message,char*K1){
  int Msg_Len=strlen(Message),K1_Len=strlen(K1);
  char*T=malloc(Msg_Len);
  int F=0;
  for(int i=0;i<K1_Len;i++){
    for(int y=0;y<K1_Len;y++){
      if(K1[y]=='0'+i){
    for(int u=y;u<Msg_Len;u+=K1_Len){
      T[F]=Message[u];
      F++;
    }
      }
    }
  }
  return T;
}

char*Disrupted_Transpose(char*Message,char*K2){
  int Msg_Len=strlen(Message),K2_Len=strlen(K2);
  char*T=malloc(Msg_Len);
  for(int y=0;y<Msg_Len;y++){
    T[y]=' ';
  }
  int F=0;
  int P=0;
  for(int u=0;u<K2_Len;u++){
    for(int v=0;v<K2_Len;v++){
      T[F]=Message[P];
      P++;F++;
      if(K2[v+1]-'0'==u){
        for(int C=1;C<K2_Len-v;C++){
      F+=K2_Len-v-C;
      for(int E=0;E<=v+C;E++){
        if(F<Msg_Len&P<Msg_Len){
          T[F]=Message[P];
        }
        F++;P++;
      }
    }
    break;
      }
    }
    if(F>Msg_Len){
      break;
    }
  }
  int U=0;
  for(int g=0;g<Msg_Len;g++){
    U=(T[g]-'0'<10&-1<T[g]-'0')?U+1:U;
  }
  for(int j=U;j<Msg_Len;j++){
    for(int x=0;x<Msg_Len;x++){
      if(T[x]==' '){
    T[x]=Message[j];
    break;
      }
    }
  }
  return Transpose(T,K2);
}

void VIC_Encoder(char*Message,char*Phrase,char*Key,int a_id,char*date,char*m_id,char null){
  char*S1=malloc(10);
  char*S2=malloc(10);
  for(int i=0;i<20;i++){
    if(i<10){
      S1[i]=Key[i];
    }
    else{
      S2[i-10]=Key[i];
    }
  }
  S1=Sequent(S1);
  S2=Sequent(S2);
  char*M=malloc(5);
  for(int i=4;i>-1;i--){
    M[i]='0'+(((m_id[i]-'0')-(date[i]-'0'))%10);
  }
  char*G=Chain_Add(M,5,0);
  for(int y=0;y<10;y++){
    G[y]='0'+(((S1[y]-'0')+(G[y]-'0'))%10);
  }
  char*N="0123456789";
  char*T=malloc(10);
  for(int q=0;q<10;q++){
    for(int t=0;t<10;t++){
      if(N[t]==G[q]){
    T[q]=S2[t];
      }
    }
  }
  char*Z=Chain_Add(T,50,0);
  char*U=malloc(50);
  for(int h=0;h<50;h++){
    U[h]=Z[h+10];
  }
  int p,q;
  for(int b=49;b>10;b++){
    if(U[b]!=U[b-1]){
      q=a_id+(U[b]-'0');
      p=a_id+(U[b-1]-'0');
      break;
    }
  }
  char*seqT=Sequent(T);
  char*V=malloc(50);
  int Count=0;
  for(int j=0;j<10;j++){
    for(int o=0;o<10;o++){
      if(seqT[o]=='0'+j){
    for(int x=o;x<o+41;x+=10){
      V[Count]=U[x];
      Count+=1;
    }
      }
    }
  }
  char*K1=malloc(p);
  char*K2=malloc(q);
  for(int D=0;D<p+q;D++){
    if(D<p){
      K1[D]=V[D];
    }
    else{
      K2[D-p]=V[D];
    }
  }
  K1=Sequent(K1);
  K2=Sequent(K2);
  char*C=malloc(10);
  for(int b=40;b<50;b++){
    C[b-40]=U[b];
  }
  C=Sequent(C);
  char*Transposed_2=Disrupted_Transpose(Transpose(Straddling_Checkerboard(C,Phrase,Message,null),K1),K2);
  int O=0;
  for(int B=0;B<strlen(Transposed_2)/5+1;B++){
    if(B==strlen(Transposed_2)/5-date[strlen(date)-1]+'1'){
      printf("%s ",m_id);
    }
    else{
      for(int J=O;J<O+5;J++){
    printf("%c",Transposed_2[J]);
      }
      printf(" ");
      O+=5;
    }
  }
}

टिप्पणियाँ

  • यह संदेश को एन्कोड करने के लिए निम्न के समान एक बिसात का उपयोग करता है:

      3 4 5 6 2 3 4 5 6 7
  S E N A T O R I     
6 B C D F G H J K L M 
7 P Q U V W X Y Z . #

  • यह मानता है कि सभी लागू तार अपरकेस में दिए गए हैं। संदेश में सभी विराम चिह्नों को छोड़कर अवधि होनी चाहिए और सभी संख्याओं को #s द्वारा सीमांकित किया जाना चाहिए, जबकि मुख्य वाक्यांश में सभी विराम चिह्न हटा दिए जाने चाहिए ।

  • परिणामस्वरूप एन्कोडेड संदेश स्पेस-अलग-पांच-अंकीय समूहों के स्ट्रिंग के रूप में STDOUT में आउटपुट है।

  • इनपुट संदेश अंग्रेजी में होना चाहिए।

  • मैंने अपने द्वारा उपयोग किए जाने वाले कुछ कार्यों को संयोजित किया होगा, लेकिन फिर मुझे दो-अक्षर वाले चर नामों का उपयोग करना होगा, अंतिम कार्यक्रम को कुछ और कार्यों के साथ अधिक लंबा बनाना होगा।

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

— आर। कप
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 946 938 953 बाइट्स

V=(c,d,f,g,j,k,m)=>{S=a=>a.split``,J=a=>a.join``,A=(a,b)=>{for(i=0;a[L="length"]<b;a+=(a[i++]- -a[i])%h);return a},Q=b=>(a=S(b).sort(),S(b).map(b=>a[i=a[X="indexOf"](b)]=i)),u=A(t=J(S(A(J(S(k).map((a,b)=>Math.abs(a-g[b]))),h=10)).map((a,b)=>Q(f[C="slice"](h,20))[(Q(f[C](0,h))[b]- -a)%h])),60)[C](h),T=((a,b,c)=>{if(r=Array(l=b[L]).fill(""),c){for(e=a[L]/l,i=0,w=[],u=R=b[X](x=0);i<e;)w[i++]=a[P](0,R++),u?u=0:R>l||(R=b[X](u=++x));for(i=0;i<e;)w[i]=J(w[i].concat(a[P](0,l-w[i++][L])));a=J(w)}for(i in a)r[+b[i%l]]+=a[i];return r}),v=J(T(u,Q(t))),q=J(Q(u[C](-h))),t="ABCDEFGHIJKLMNOPQRSTUVWXYZ#".match(new RegExp("[^"+d+"]","g")),t[P="splice"](9,0,"."),M=[];for(i in t)M[t[i]]=q[8^i/h]+(M[d[i]]=q[i%h]);for(n=c[L],b=J((c[C](n-=new Date%n)+"."+c[C](0,n)).split(/ |/).map(a=>M[a]||a)),b+=m.repeat(5-b[L]%5),i=f=q=49;f==q;)f=+u[i-1]+j,q=+u[i++]+j;return t=J(T(S(J(T(b,Q(v[C](0,f))))),Q(v.substr(f,q)),1)).match(/.{5}/g),g=-g[C](-1),g++&&t[P](g||t[L],0,k),t}

मैंने देखा कि सप्ताहांत में अभी तक इसके लिए कोई जेएस प्रविष्टि नहीं थी, इसलिए यहां मेरा (अंतिम मिनट) प्रयास है। इसे लागू करने और गोल्फिंग उतना ही पागल था जितना कि यह मजेदार था!

डेमो स्निपेट

कोड स्निपेट दिखाएं

संपादित करें: -8 बाइट्स

एहसास हुआ कि समारोह के आसपास अतिरिक्त कोष्ठक थे S,J,A,Q

संपादित करें: +15 बाइट्स

message idअंतिम संदेश (अब 1-अनुक्रमित और 0 इसे आउटपुट में शामिल नहीं करता है) के लिए तर्क को अपडेट किया गया है ।

Ungolfed

chainAdd = (s,l)=>{for(i=0;s.length<l;s+=(s[i++]- -s[i])%10);return s;}

sequentialize = (s)=> {
    a=s.split('').sort();
    return s.split('').map(c=>(i=a.indexOf(c),a[i]='',i));  
}

transpose = (s,k,disruptive)=>{
    var result=Array(k.length).fill('')
    if(disruptive){
        rows=[]
        k_index=0;
        rowLength=k.indexOf(k_index);
        triangling=!rowLength;

        expectedRows = s.length/k.length
        for(row=0;row<expectedRows;row++){
            rows[row]=s.splice(0,rowLength++)
            if(triangling){     
                if(rowLength>k.length){
                    triangling=false;
                    rowLength=k.indexOf(++k_index)              
                }
            }
            else{               
                triangling=true;
            }
        }

        for(row=0;row<expectedRows;row++){
            rows[row]= rows[row].concat(s.splice(0,k.length-rows[row].length)).join('')
        }
        s=rows.join('')
    }
    for(i in s)
        result[+k[i%k.length]]+=s[i];   
    return result;
}

checkerboard =(message,seq, keyword, nulls)=>{  
    t='ABCDEFGHIJKLMNOPQRSTUVWXYZ#'.match(new RegExp('[^'+keyword+']','g'));
    t.splice(9,0,'.')

    map=[]
    for(i in t)
        map[t[i]]=(seq[8^(i/10)])+(map[keyword[i]]=seq[i%10])

    r = new Date%message.length;
    rotateMessage=message.substr(message.length-r)+'.'+message.substr(0,message.length-r)

    result =rotateMessage.split(/ |/).map(x=>map[x]||x).join('');
    result+=nulls.repeat(5-result.length%5)

    return result;
}

vic = (message, keyword, phrase, date, agent, m_id, nulls)=>{
    s1=sequentialize(phrase.substr(0,10))//.join('')
    s2=sequentialize(phrase.substr(10,10))//.join('')

    r = m_id.split('').map((x,i)=>Math.abs(x-date[i])).join('')
    g = chainAdd(r,10).split('').map((x,i)=>(s1[i]- -x)%10);

    t = g.map(i=>s2[+i]).join('');
    u=chainAdd(t,60).substr(10)

    var p,q;
    for(i=49;p==q;i++){
        p=agent + +u[i-1];
        q=agent + +u[i];
    }
    seqT = sequentialize(t);
    v=transpose(u,seqT).join('');

    k1 = sequentialize(v.substr(0,p));
    k2 = sequentialize(v.substr(p,q));
    c  = sequentialize(u.substr(-10)).join('')

    CB =checkerboard(message,c, keyword, nulls);
    t1=transpose(CB,k1).join('')
    t2=transpose(t1.split(''),k2,1).join('').match(/.{5}/g);
    (d=-date.substr(-1))&&t2.splice((d+1)||t2.length,0,m_id);
    return t2;
}

टिप्पणियाँ

  • यह संदेश को एन्कोड करने के लिए निम्न के समान एक बिसात का उपयोग करता है:

      3 1 0 5 9 6 8 7 2 4
  S E N A T O R I
2 B C D F G H J K L .
4 M P Q U V W X Y Z #

  • सभी तार अपरकेस में दिए गए हैं। संदेश अक्षरांकीय लैटिन है (प्लस .और #) और सभी विराम (अवधि को छोड़कर) को हटा दिया होनी चाहिए। सभी नंबरों को पहले से ही चिन्हित किया जाना चाहिए #। मुख्य वाक्यांश में सभी विराम चिह्न / रिक्त स्थान होने चाहिए।

  • परिणामी संदेश 5 अंकीय स्ट्रिंग्स की एक सरणी के रूप में वापस आ गया है

संवर्द्धन

  • मुझे लगता है कि कुछ बाइट्स को बचाने के लिए "सभी भाषाओं" का दुरुपयोग करने का एक तरीका है। यदि मेरे पास अधिक समय होता तो मैं यह मान लेता कि भाषा कुछ हवाई जैसी है जिसमें केवल 12 अक्षर हैं।

  • किसी भी गोल्फ सुझाव का हमेशा स्वागत है।

— SLuck49
स्रोत
क्या आप कृपया एक स्निपेट जोड़ सकते हैं ताकि मैं सत्यापित कर सकूं कि यह काम करता है? अगर ऐसा होता है, तो मैं आपको इनाम दे सकता हूं।
— आर। कप
@ R.Kap ज़रूर, मैंने एक डेमो स्निपेट जोड़ा है
— SLuck49
हम्म ... डेमो में, के बजाय अंत से दूर message identifierहोने लगता है । साथ ही, आपके अनगुल्ड संस्करण में, अंत के बजाय शुरुआत से ही दूर होना प्रतीत होता है । 76Id6
— आर। कप
@ R.Kap हाँ, जब मैंने पहली बार इसे पोस्ट किया था तो एक बग था (इसे अनऑल्फ़ॉल्ड में ठीक नहीं किया जाना चाहिए)। गोल्फ के लिए के रूप में, मैंने मान लिया कि 0-अनुक्रमित था क्योंकि अन्यथा अगर 1बहुत अंत का मतलब है तो आप कहां message identifierपर जाना चाहिए 0? मैं इसे बदल सकता हूं मुझे सिर्फ जानने की जरूरत है।
— SLuck49
मैं कहूँगा कि पर एक उत्पादन से हटा दिया जाना चाहिए। 0message identifier
— आर। कप
1

क्लोजर, 1197 1212 बाइट्स

औघ, मैं थक गया हूं।

अपडेट: संदेश के आवश्यक यादृच्छिक विभाजन स्थान को जोड़ा गया है, ungolfed संस्करण दिए गए उदाहरण के समान स्थान का उपयोग करता है ताकि एल्गोरिथ्म को आसानी से सत्यापित किया जा सके।

(defn enc[I K E D Y M](let[P split-at A concat Z zipmap R partition W mapcat % count X repeat O vector / map x(fn[C](apply / O C))G range t 10 r(G t)m(fn[i](mod i t))F(fn[[n & N]](/ last(iterate(fn[[[b & N]a]][(A N[(m(+ a b))])b])[N n])))Q(fn[S](for[i(G(% S))a[(nth S i)]](apply +(%(filter #{a}(take i S)))(for[b S :when(pos?(compare a b))]1))))[S J](/ Q(P t(take 20 E)))T(/(Z r J)(/ m(/ + S(F(/ - M D)))))U(take 50(drop t(F T)))l(last U)p(+ Y(last(remove #{l}U)))V(W(Z(Q T)(x(R t U)))r)[k j](/ Q(P p(take(+ p Y l)V)))B(into(Z(/ char(G 48 58))(G))(/(fn[i c][c(+(*(quot i 10)20)(nth(Q(reverse(take t(reverse U))))(m i)))])(G)(A(str K",,")(remove(set K)(/ char(A(G 65 91)".#"))))))?(% k)T(vec(filter some?(W(Z k(x(R ?(A(flatten(R 5(A(W str(/ B(let[[b e](P(rand-int(count I))I)](apply str(A e".. "b)))))(X 4(B\,)))))(X(dec ?)nil)))))(G ?))))w (% j)NR(+(quot(% T)w)1)L(flatten(for[k r](for[i(G(.indexOf j k)(inc w))](G i))))C(for[[r c](/ O(rest(reductions + -1(/(fn[i](get{0 1}i 0))L)))L):when(< r NR)][r c])H(R 5(filter some?(W(Z j(x(R w (A(vals(into(sorted-map)(/ O(A C(for[i(G NR)j(G w)c[[i j]]:when(not((set C)c))]c))T)))(X(dec w)nil)))))(G w))))](/(fn[p](apply str p))(let[[b e](P(-(% H)(D 6)-1)H)](A b[M]e)))))

नमूना आदानों और परीक्षण के मामले:

(def mymsg (clojure.string/upper-case "We are discovered. Take what you can. Burn everything else. Move to Safehouse Foxtrot#3#"))
(def mykey "SENATORI")
(def mypharase (clojure.string/upper-case (apply str (remove #{\space} "The first principle is that you must not fool yourself — and you are the easiest person to fool."))))
(def mydate [3 1 7 2 0 1 6])
(def mynum 9)
(def M [4 7 9 2 1])

;("61231" "12824" "71192" "58609" "92185" "48612" "14927" "22944" "34046" "13348" "04159" "38645" "70546" "20254" "22026" "64584" "21904" "47921" "90253" "42694" "42221" "56644" "14541")
(enc mymsg mykey mypharase mydate mynum M)

Ungolfed:

(defn enc[mymsg mykey mypharase mydate mynum M]
  (let[t       10
       r       (range t)
       m       (fn[i](mod i t))
       lagfib  (fn[[n & N]](map last(iterate(fn[[[b & N]a]][(concat N[(m(+ a b))])b])[N n])))
       toseq   (fn[S](for[i(range(count S))a[(nth S i)]](apply +(count(filter #{a}(take i S)))(for[b S :when(pos?(compare a b))]1))))
       [S1 S2] (map toseq(split-at t(take 20 mypharase)))
       M2      (take t(lagfib(map - M mydate)))
       G       (map m(map + S1 M2))
       Gmap    (zipmap r S2)
       T       (map Gmap G)
       U       (take 50(drop t(lagfib T)))
       L2      (last U)
       L1      (last(remove #{L2}U))
       p       (+ mynum L1)
       q       (+ mynum L2)
       seqT    (toseq T)
       V       (mapcat(zipmap seqT(apply map vector(partition t U)))r)
       [K1 K2] (map toseq(split-at p(take(+ p q)V)))
       C       (toseq(reverse(take t(reverse U))))
       B       (into(zipmap(map char(range 48 58))(range))(map(fn[i c][c(+(*(quot i 10)20)(nth C(m i)))])(range)(concat(str mykey",,")(remove(set mykey)(map char(concat(range 65 91)".#"))))))
      ;B       (into(zipmap(map char(range 48 58))(range))(map(fn[i c][c(+(nth C(quot i 3))(*(mod i 3)20))])(range)(flatten(apply map vector(partition 10(apply concat mykey",,"(apply map vector (partition 2(remove(set mykey)(map char(concat(range 65 91)".#")))))))))))
       N1      (count K1)
       mymsg   (flatten(partition 5(concat(mapcat str(map B(let[[b e](split-at 49 mymsg)](apply str(concat e".. "b)))))(repeat 4(B\,)))))
       T1      (vec(filter some?(mapcat(zipmap K1(apply map vector(partition N1(concat mymsg(repeat(dec N1)nil)))))(range N1))))
       N2      (count K2)
       NR      (+(quot(count T1)N2)1)
       cols    (flatten(for[k r](for[i(range(.indexOf K2 k)(+(count K2)1))](range i))))
       rows    (rest(reductions + -1(map(fn[i](get{0 1}i 0))cols)))
       coords  (for[[r c](map vector rows cols):when(< r NR)][r c])
       coords  (concat coords(for[i(range NR)j(range N2)c[[i j]]:when(not((set coords)c))]c))
       T2      (partition 5(filter some?(mapcat(zipmap K2(apply map vector(partition N2(concat(vals(into(sorted-map)(map vector coords T1)))(repeat(dec N2)nil)))))(range N2))))]
    (map(fn[p](apply str p))(let[[b e](split-at(-(count T2)(mydate 6)-1)T2)](concat b[M]e)))))

यह चेकबोर्ड पर एक वैकल्पिक कार्यान्वयन है Bजो कार्य परिभाषा पर समान है। लेकिन सबमिशन एक दूसरे का उपयोग करता है जिसमें अप्रयुक्त अक्षर पहले 2 पंक्ति को भरते हैं और फिर कॉलम-बाय-कॉलम को भरने के बजाय 3।

— NikoNyrh
स्रोत
क्लोजर सॉल्यूशन लिखने पर विचार किया, लेकिन जब मैं सवाल पढ़ रहा था तो मेरा सिर फट गया। लिखने में कितना समय लगा?
— कारिन्जिनेट
हो सकता है कि साइड में Youtube देखते समय 3 घंटे हो। यह काफी आसान शुरू हुआ लेकिन मैं तब हार मानने वाला था जब मुझे दूसरा "बाधित ट्रांसपोज़न" लागू करना पड़ा। अब जो coordsदो बार उत्पन्न होता है, पहले त्रिकोणीय आकार उत्पन्न करता है और फिर कोई निर्देशांक भरता है जो गायब थे। इसके अलावा "एन के
— गुणक
अरे धिक्कार है कि मैं हार्ड-कोडित विभाजन बिंदु को बदलना भूल गया (split-at 49 mymsg), 49 को कुछ ऐसा होना चाहिए जैसे (rand-int(count mymsg))कि सही उत्तर 1200 से अधिक बाइट्स हो। zzz
— निकोनिरह
अरे नहीं। हालांकि सी उत्तर की तुलना में शायद अभी भी कम है।
— बजे कार्सिजेनेट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.