पहेली मशीन को लागू करें

Question

एनिग्मा मशीन एक काफी जटिल सिफर मशीन है जिसका इस्तेमाल जर्मन और अन्य अपने संदेशों को एन्क्रिप्ट करने के लिए करते हैं। इस मशीन को लागू करना आपका काम है *।

चरण 1, रोटेशन

हमारे एनिग्मा मशीन में रोटर्स के लिए 3 स्लॉट हैं, और इनमें से प्रत्येक स्लॉट के लिए 5 उपलब्ध रोटार हैं। प्रत्येक रोटर 26 विभिन्न संभव पदों (से है Aकरने के लिए Z)। प्रत्येक रोटर में एक पूर्वनिर्धारित पायदान स्थिति होती है :

Rotor  Notch
------------
1      Q
2      E
3      V
4      J
5      Z

कीबोर्ड पर निम्नलिखित चरण होते हैं:

1. स्लॉट 1 में रोटर घूमता है
2. यदि स्लॉट 1 में रोटर अपने पायदान से आगे बढ़ता है, तो यह स्लॉट 2 में रोटर को घुमाता है।
3. यदि स्लॉट 2 में रोटर अपने पायदान में है (लेकिन अभी वहां नहीं चला है), रोटर 2 और 3 दोनों एक बार घूमते हैं।

हम रोटार 1,3,5 का उपयोग कर रहे हैं और वे स्थिति में हैं P,U,Hतो पदों की अनुक्रम है: P,U,H> Q,U,H> R,V,H>S,W,I

चरण 2, प्रतिस्थापन

प्रत्येक रोटर एक साधारण चरित्र प्रतिस्थापन करता है। निम्नलिखित Aस्थिति में प्रत्येक रोटर का एक चार्ट है :

  ABCDEFGHIJKLMNOPQRSTUVWXYZ
  --------------------------
1 EKMFLGDQVZNTOWYHXUSPAIBRCJ
2 AJDKSIRUXBLHWTMCQGZNPYFVOE
3 BDFHJLCPRTXVZNYEIWGAKMUSQO
4 ESOVPZJAYQUIRHXLNFTGKDCMWB
5 VZBRGITYUPSDNHLXAWMJQOFECK
R YRUHQSLDPXNGOKMIEBFZCWVJAT

स्थिति 1 में रोटर 1 है PAIBRCJEKMFLGDQVZNTOWYHXUS, जो पत्र के Cलिए स्थानापन्न करेगा I।

तीन रोटार अपने प्रतिस्थापन का प्रदर्शन करने के बाद, परावर्तक हिट ( Rऊपर के रूप में सूचीबद्ध ) है। यह अपना प्रतिस्थापन करता है, और फिर रोटार के माध्यम से वापस सिग्नल को दर्शाता है। रोटार फिर रिवर्स ऑर्डर में एक रिवर्स प्रतिस्थापन करते हैं।

रिवर्स प्रतिस्थापन का मतलब है कि रोटर 1 के बजाय प्रतिस्थापन के Aसाथ E, यह प्रतिस्थापन Eकरता हैA

स्लॉट्स रोटर से भरे हुए हैं 1,2,3 सभी स्थिति में A। पत्र रोटर्स के माध्यम से Qपथ का अनुसरण करता है Q>X>V>M। Mपरिलक्षित होता है O, जो तब के विपरीत मार्ग का अनुसरण करता है O>Z>S>S। इसलिए, Aके साथ प्रतिस्थापित किया जाता है S।

इनपुट आउटपुट

आप उत्तीर्ण हैं:

1. 3 रोटार की एक सूची (पूर्णांक के रूप में)
2. 3 शुरू रोटर पदों की एक सूची (पत्र के रूप में)
3. एक स्ट्रिंग जिसे एन्क्रिप्ट करने की आवश्यकता है।

आप मान सकते हैं कि आपका इनपुट अच्छी तरह से बनेगा, और सभी अक्षर अपरकेस अक्षर होंगे, कोई स्पेस नहीं।

आपको एन्क्रिप्टेड स्ट्रिंग को वापस करना होगा।

आप वैकल्पिक रूप से रोटार, नॉच और रिफ्लेक्टर को इनपुट के रूप में स्वीकार कर सकते हैं। उन लोगों के लिए जो अपने स्कोर से 95 बाइट्स नहीं निकाल सकते, जैसे कि95 = ceil(log2(26 letters ^(26*6 rotors +5 notches))/8 bytes)

परीक्षण के मामलों

Rotor Position Input              Output
4,1,5 H,P,G    AAAAAAAAA          RPWKMBZLN
1,2,3 A,A,A    PROGRAMMINGPUZZLES RTFKHDOVZSXTRMVPFC
1,2,3 A,A,A    RTFKHDOVZSXTRMVPFC PROGRAMMINGPUZZLES
2,5,3 U,L,I    GIBDZNJLGXZ        UNCRACKABLE

मेरा कार्यान्वयन जीथब पर पाया जा सकता है । मैंने इसका परीक्षण किया है, लेकिन मेरे कार्यान्वयन में कीड़े हो सकते हैं (इसका मतलब यह होगा कि मेरे परीक्षण के मामले गलत हैं)।

_{* मैंने इसे यथासंभव सटीक बनाने की कोशिश की है , लेकिन मशीनों के बीच भिन्नता के कारण, मेरे पास कुछ विवरण गलत हो सकते हैं। हालाँकि, आपका काम यह है कि मैंने जो भी वर्णन किया है, उसे लागू करें, भले ही मैं गलत हूँ। मैं सादगी के लिए प्लगबोर्ड शामिल नहीं कर रहा हूँ}

Comments

यह Enigma I, M3 & M4 में उपयोग किए जाने वाले एन्क्रिप्शन एल्गोरिथम के लिए एक सही कार्यान्वयन है। सभी सेटिंग्स, मौजूद हैं प्लग बोर्ड और के रूप में Uhr स्विच काम अच्छी तरह से: https://github.com/arduinoenigma/ArduinoEnigmaEngineAndUhr यह वही एन्क्रिप्शन में इस्तेमाल इंजन है Arduino पहेली मशीन सिम्युलेटर

मुझे लगता है कि मैं समझता हूं, लेकिन यह सही काम नहीं करता है। यहाँ यह बताने वाला एक जिस्ट है । gith.github.com/JJ-Atkinson/ddd3896fe10d85b3b584 ।

— जे एटकिन

पहले उदाहरण में आपने कहा था "अगर हम रोटर्स 1, 3 और 5 का उपयोग कर रहे हैं" लेकिन मुझे लगता है कि यह रोटर्स 1, 2 और 5 होगा (या जो कुछ भी अंतिम होगा)।

— coredump

@coredump फिक्स्ड

— नाथन मेरिल

क्या मेरी समझ है कि रोटर्स अभी भी कैसे गलत हैं?

— जे एटकिन

Answer 1

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

मुझे लगता है कि यह सही ढंग से काम कर रहा है। रोटार इसके पास गए:

def z(p,o,m,f,g,h):
 O=ord;b=lambda a:a[1:]+a[:1];d=lambda a:chr(a+O('A'));e=lambda a:O(a)-O('A');i=[list(g[i-1])for i in p];j=[f[i-1]for i in p];i=[x[e(y):]+x[:e(y)]for x,y in zip(i,o)];k=[]
 for l in m:
  if i[0][0]==j[0]:i[1]=b(i[1])
  elif i[1][0]==j[1]:i[1]=b(i[1]);i[2]=b(i[2])
  i[0]=b(i[0]);c=l
  for n in i:c=n[e(c)]
  c=h[e(c)]
  for n in reversed(i):c=d(n.index(c))
  k+=[c]
 return''.join(k)

fपायदान है, gरोटर्स है और hरिफ्लेक्टर है।

Ungolfed:

shift = lambda rotor: rotor[1:] + rotor[:1]
letter = lambda num: chr(num + ord('A'))
number = lambda chr: ord(chr) - ord('A')


def encode(rotors, rotorStart, message, defaultRotors, reflector, rotorNotchPositions):
    usedRotors = [list(defaultRotors[i - 1]) for i in rotors]
    notches = [rotorNotchPositions[i - 1] for i in rotors]
    usedRotors = [rotor[number(offset):] + rotor[:number(offset)] for rotor, offset in zip(usedRotors, rotorStart)]

    sub = []

    for char in message:
        # print([''.join(rotor) for rotor in usedRotors])
        if usedRotors[0][0] == notches[0]:
            usedRotors[1] = shift(usedRotors[1])
        elif usedRotors[1][0] == notches[1]:
            usedRotors[1] = shift(usedRotors[1])
            usedRotors[2] = shift(usedRotors[2])

        usedRotors[0] = shift(usedRotors[0])

        c = char
        for rotor in usedRotors:
            c = rotor[number(c)]
        c = reflector[number(c)]
        for rotor in reversed(usedRotors):
            c = letter(rotor.index(c))
        sub += [c]
        print([''.join(rotor) for rotor in usedRotors], char, c, message)

    return ''.join(sub)

rotorNotchPositions = 'QEVJZ'
*defaultRotors, reflector = [
    #ABCDEFGHIJKLMNOPQRSTUVWXYZ#
    "EKMFLGDQVZNTOWYHXUSPAIBRCJ",  # 1
    "AJDKSIRUXBLHWTMCQGZNPYFVOE",  # 2
    "BDFHJLCPRTXVZNYEIWGAKMUSQO",  # 3
    "ESOVPZJAYQUIRHXLNFTGKDCMWB",  # 4
    "VZBRGITYUPSDNHLXAWMJQOFECK",  # 5
    "YRUHQSLDPXNGOKMIEBFZCWVJAT"   # R
]

#             Rotor       Position        Input                 Output
assert encode((4, 1, 5), ('H', 'R', 'G'), 'AAAAAAAAA',
              defaultRotors, reflector, rotorNotchPositions) == 'PXSHJMMHR'
assert encode((1, 2, 3), ('A', 'A', 'A'), 'PROGRAMMINGPUZZLES',
              defaultRotors, reflector, rotorNotchPositions) == 'RTFKHDOCCDAHRJJDFC'
assert encode((1, 2, 3), ('A', 'A', 'A'), 'RTFKHDOVZSXTRMVPFC',
              defaultRotors, reflector, rotorNotchPositions) == 'PROGRAMRXGVGUVFCES'
assert encode((2, 5, 3), ('U', 'L', 'I'), 'GIBDZNJLGXZ',
              defaultRotors, reflector, rotorNotchPositions) == 'UNCRAUPSCTK'

मुझे लगता है कि यह काम कर रहा है, लेकिन यह एक अलग आउटपुट का उत्पादन करता है, जो कि (मुझे लगता है) संदर्भ प्रत्यारोपण में एक बग है।