बेकन का सिफर: एन इंट्रो टू स्टेनगनोग्राफी

Question

यह छोटी सी गुल्लक बाजार गई, इस छोटी गुल्लक ने कुछ कोड लिखे ...

आह रुको, हम उस बेकन के बारे में बात नहीं कर रहे हैं, हम सर फ्रांसिस बेकन के बारे में बात कर रहे हैं! विशेष रूप से, सिफर बेकन 1500 के दशक के अंत में तैयार हुआ , एक संदेश को दूसरे संदेश के भीतर छिपाने की एक विधि के रूप में, स्टेग्नोग्राफ़ी की एक विधि ।

पाठ की प्रस्तुति में संदेश को उसकी सामग्री के बजाय छुपाकर काम करता है । सबसे पहले, आपके संदेश के अक्षर बाइनरी में एन्कोडेड हैं (0 से 25 तक) निम्नानुसार हैं:

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

Letter  Encoding
A       AAAAA
B       AAAAB
C       AAABA
D       AAABB
E       AABAA
F       AABAB
G       AABBA
H       AABBB
I       ABAAA
J       ABAAB
K       ABABA
L       ABABB
M       ABBAA
N       ABBAB
O       ABBBA
P       ABBBB
Q       BAAAA
R       BAAAB
S       BAABA
T       BAABB
U       BABAA
V       BABAB
W       BABBA
X       BABBB
Y       BBAAA
Z       BBAAB

ऊपर Aऔर Bs में अपने संदेश के सभी अक्षरों को कूटबद्ध करने के बाद , अब आपको अपने कोड के लिए दो प्रकारों का चयन करना होगा । इस उदाहरण के लिए, मैं टाइपफेस के लिए सामान्य पाठ का उपयोग करेगा Aऔर बोल्ड पाठ टाइपफेस के लिए B।

तो संदेश

HELLOWORLD

को एन्कोड किया गया है

AABBB AABAA ABABB ABABB ABBBA BABBA ABBBA BAAAB ABABB AAABB

और अब हम इस बाइनरी को एक वाहक पाठ के साथ छिपाते हैं ।

तेज भूरे लोमड़ी आलसी कुत्तों पर कूद पड़ती है, जिन खेतों में चरवाहे नजर रखते हैं।

यह ठीक है यदि वाहक संदेश वास्तविक एन्कोडेड संदेश से अधिक लंबा है, हालांकि यह छोटा नहीं हो सकता है। अब हम वाहक टेक्स्ट को बोल्ड में बदल देते हैं, जहां के अनुसार Bएन्कोडेड संदेश में हैं,

Th e qu ic k bro w n fo x j u mp s ove r t h e l a az y do g s , gam b o o l i ng मैं वह टी क्षेत्रों में जहां चरवाहों को देखता रहता है।

जिसे मार्कडाउन के बिना पढ़ता है

Th**e** **qu**ic**k** bro**w**n **fo**x **j**u**mp**s **ove**r **t**h**e** **l**az**y** 
**do**g**s**, gam**b**o**l**i**ng** in t**he** fields where the shepherds keeps watch.

ध्यान दें कि मैंने संदेश को एन्कोड करने के लिए वाहक संदेश में विराम चिह्न का उपयोग नहीं किया था, लेकिन क्या विराम चिह्न एन्कोड किया गया है या आप पर निर्भर नहीं है /।

नियम

• आपका इनपुट आपके द्वारा एन्कोड किया गया संदेश और वाहक संदेश होगा। यदि वाहक संदेश बहुत छोटा है, तो किसी प्रकार का त्रुटि संदेश लौटाएं।

• आपको एन्कोडिंग के लिए दो प्रकारों का चयन करना होगा Aऔर B, जैसे कि UPPERCASE, लोअरकेस, इटैलिक , बोल्ड , बोल्ड इटैलिक , स्ट्राइकथ्रू , in code formatऔर इसी तरह। इन टाइपफेस को एनकोड करने के लिए आपको स्टैक एक्सचेंज के मार्कडाउन के फॉर्म का उपयोग करना होगा

  UPPERCASE, lowercase, *italic*, **bold**, 
  ***bold italic***, <s>strikethrough</s>, `in code format`
  

• आपका आउटपुट आपका अब-इनकोडेड कैरियर संदेश होना चाहिए, या तो मार्कडाउन के साथ दिखाया गया है या बिना दिखाया गया है, जैसा कि ऊपर दिए गए उदाहरण में देखा गया है।

• आप केवल एक एन्कोडिंग एल्गोरिथ्म बनाने के लिए आवश्यक हैं। आपके द्वारा प्रदान किए जाने वाले किसी भी डिकोडिंग एल्गोरिदम का स्वागत है, लेकिन लेखन के समय आपके स्कोर में मदद या बाधा नहीं होगी।

• आपका कोड एक कार्यक्रम या एक फ़ंक्शन होना चाहिए।

• यह कोड गोल्फ है, इसलिए सबसे छोटी संख्या बाइट्स जीतती है।

हमेशा की तरह, अगर समस्या स्पष्ट नहीं है, तो कृपया मुझे बताएं। गुड लक और गुड गोल्फिंग!

Comments

इसलिए वास्तव में ऊपरी / लोअरकेस का उपयोग नहीं करने का कोई कारण नहीं है, क्योंकि बाकी सब कुछ अधिक बाइट्स का खर्च करता है

— Mego

मुझे लगता है कि "हम उस बेकन के बारे में बात नहीं कर रहे हैं" में एक टाइपो है , क्योंकि निश्चित रूप से आप केविन बेकन के बारे में बात कर रहे थे, इसलिए "बी" को पूंजीकृत होना चाहिए, है ना?

— मार्टिन एंडर

Answer 1

पायथ, 47 बाइट्स

Vsm.[05jxGd2r~zw0#I}Jr@z~Z+1Z0GBpJ)p?NrJ1J;>zZ

इसे यहाँ आज़माएँ ।

स्पष्टीकरण:

             ~zw                               - Get the first line of input and 
                                               - set z to the next line
            r   0                              - Turn it to lower case
  m                                            - Map each character
        xGd                                    - Get it's position in the alphabet
       j   2                                   - Turn it to base 2
   .[05                                        - Pad the start with 0's
 s                                             - Turn it to a 1d-array (flatten it)
V                                        ;     - For N in above array:
                 #                )            - While 1:
                      @z~Z+1Z                  - Get the current position in the 
                                               - second line and increment the position
                    Jr       0                 - Set J to it lowercased
                  I}          GB               - If it's a letter, break
                                pJ             - Otherwise, print it
                                    ?N         - Is the character code
                                               - (the current 1d-array) 1
                                      rJ1      - Get the current char uppered
                                         J     - Leave it lowered
                                   p           - Print the character
                                           >zZ - Print out the rest of the second input

Answer 2

पायथन 3, 216 211 231 225 207 बाइट्स

यह एक ऐसा समाधान है जो अपने दो टाइपफेस के लिए सामान्य पाठ और मार्कडाउन शैली के इटैलिक का उपयोग करता है। और यह रिक्त स्थान को छोड़कर वाहक संदेश में सब कुछ एनकोड करता है।

संपादित करें: कोड को ठीक करना था ताकि परिणाम सही तरीके से प्रिंट हो और कोड के नीचे उदाहरण जोड़े।

संपादित करें: इटैलिक को सही ढंग से मुद्रित करने में समस्याओं के कारण कोड को पहले से खराब अपरकेस / लोअरकेस समाधान में संपादित किया गया।

def g(s,c):
 c=c.lower();w=[h.upper()for h in s if h.isalpha()];t=''.join("{:05b}".format(ord(i)-65)for i in w);r='';j=m=0
 while t[j:]:a=c[m];x=a!=" ";r+=[a,a.upper()][x*int(t[j])];j+=x;m+=1
 return r+c[m:]

उदाहरण

>>> g('HELLOWORLD', 'The quick brown fox jumps over the lazy dogs, gamboling in the fields 
where the shepherds keep watch')
'thE QUicK broWn FOx JuMPs OVEr ThE LazY DOgS, gaMbOlINg in THe fields where the shepherds keep watch'

Ungolfed:

def bacon(message, carrier):
    # Lowers the case of the carrier message
    carrier = carrier.lower()
    # Removing all non-alphabetic characters and making the rest uppercase
    words = ""
    for char in message:
        if char.isalpha():
            words += char.upper()
    # Encoding the message
    binary = ""
    for letter in words:
        encode = ord(letter) - 65
        binary += "{:05b}".format(encode)
    # Encoding the carrier message
    result = ""
    bin_index = 0
    char_index = 0
    while bin_index < len(binary):
        letter = carrier[char_index]
        # If letter isn't a space and it needs to be encoded
        if letter != " " and int(binary[bin_index]): 
            letter = letter.upper()
        result += type + letter + type
        # The encoding only proceeds if letter wasn't a space
        bin_index += letter != " "
        # char_index increments whether or not letter was alphabetical
        char_index += 1
    # Return the encoded text and any leftover characters from the carrier message
    return result + carrier[char_index : ]

Answer 3

सी, 124 बाइट्स

इसके लिए तर्क ASCII- संगत एन्कोडिंग (जैसे ISO-8859.1 या UTF-8) की आवश्यकता होती है। यह वाहक को जगह में संशोधित करता है, और सफलता पर 0, या गैर-शून्य अन्यथा देता है। एन्कोडिंग A== लोअर-केस और B== अपर-केस है। अप्रयुक्त वाहक अक्षर ऊपरी पर सेट होते हैं।

int f(char*p,char*s){int m=16;do{if(isalpha(*s)){*s|=32;*s-=(*p-1)&m?32:0;if(!(m/=2)){m=16;p+=!!*p;}}}while(*++s);return*p;}

व्याख्या

एक परीक्षण कार्यक्रम भी शामिल है। पहले तर्क के रूप में सांकेतिक शब्दों में बदलना और दूसरे के रूप में वाहक स्ट्रिंग पास करें।

#include <stdio.h>
#include <ctype.h>

/* ASCII or compatible encoding assumed */
int f(char *p, char *s)         /* plaintext, carrier */
{
    int m=16;                   /* mask */
    do {
        if (isalpha(*s)) {
            *s |= 32;
            *s -= (*p-1)&m ? 32 : 0;
            if (!(m/=2)) {
                /* reset mask and advance unless we reached the end */
                m=16;
                p+=!!*p;
            }
        }
    } while (*++s);

    /* 0 (success) if we finished p, else non-zero */
    return *p;
}

int main(int argc, char **argv)
{
    int r = argc < 3 || f(argv[1], argv[2]);
    if (r)
        puts("~!^%&$+++NO CARRIER+++");
    else
        puts(argv[2]);
    return r;
}

परीक्षण उत्पादन:

$ ./66019 "HELLOWORLD" "The quick brown fox jumps over the lazy dogs, gamboling in the fields where the shepherds keep watch."  
thE QUicK broWn FOx JuMPs OVEr ThE LazY DOgS, gamBoLiNG in tHE FIELDS WHERE THE SHEPHERDS KEEP WATCH.