स्टेग्नोग्राफ़िक वर्ग

Question

स्टेग्नोग्राफ़िक वर्ग

आपका काम एक स्ट्रिंग में लेना है, और एक NxNछवि उत्पन्न करना है जो इस स्ट्रिंग का प्रतिनिधित्व करता है। आपको उस एल्गोरिथ्म को भी लिखना होगा जो छवि में लेता है और इसे वापस स्ट्रिंग में भी बदल देता है। स्कोरिंग में दोनों एल्गोरिदम की बाइट गिनती शामिल होगी:

"एन्क्रिप्शन" एल्गोरिथ्म + "डिक्रिप्शन" एल्गोरिथम ।

आपको अलग-अलग पोस्ट करना चाहिए, व्यक्तिगत रूप से प्रदर्शित एन्क्रिप्शन और डिक्रिप्शन एल्गोरिदम दोनों के लिए बाइट-काउंट के साथ।

---

उदाहरण एल्गोरिथम

उदाहरण के लिए, यहाँ ब्लू चैनल में एक सरल ASCII आधारित स्टेग्नोग्राफ़िक एल्गोरिथ्म का उपयोग करके "प्रोग्रामिंग पहेलियाँ और कोड गोल्फ" दिया गया है:

#2e7250,#6ea972,#04eb6f,#0fc767,#74ab72,#ee6161
#b73b6d,#1aae6d,#f37169,#bda56e,#1fe367,#e99620
#706450,#0d3575,#146b7a,#4ea47a,#2a856c,#95d065
#3f2d73,#cef720,#bab661,#d1b86e,#f22564,#12b820
#0f3d43,#c86e6f,#1ee864,#a66565,#247c20,#c3bb47
#0e296f,#89d46c,#585b66,#c08f20,#455c20,#136f20

वास्तविक छवि ( )

आप देख सकते हैं कि नीले चैनल में इस छवि के लिए केवल अस्सी के मान हैं:

50 =  80(P) 72 = 114(r) 6f = 111(o) 67 = 103(g) 72 = 114(r) 61 =  97(a) 
6d = 109(m) 6d = 109(m) 69 = 105(i) 6e = 110(n) 67 = 103(g) 20 =  32( ) 
50 =  80(P) 75 = 117(u) 7a = 122(z) 7a = 122(z) 6c = 108(l) 65 = 101(e) 
73 = 115(s) 20 =  32( ) 61 =  97(a) 6e = 110(n) 64 = 100(d) 20 =  32( ) 
43 =  67(C) 6f = 111(o) 64 = 100(d) 65 = 101(e) 20 =  32( ) 47 =  71(G) 
6f = 111(o) 6c = 108(l) 66 = 102(f) 20 =  32( ) 20 =  32( ) 20 =  32( )

जबकि बाकी चैनल छवि में रंगों की विविधता को "मसाला" करने के लिए यादृच्छिक रूप से उत्पन्न मान रखते हैं। संदेश को छवि से बाहर खींचते समय, हम बस अन्य चैनल मानों को अनदेखा कर सकते हैं, और ब्लू चैनल में हेक्स बिट को खींच सकते हैं, स्ट्रिंग को फिर से संगठित कर सकते हैं:

"Programming Puzzles and Code Golf"

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

---

नियम

• आपको प्रति पिक्सेल 1 वर्ण सांकेतिक शब्दों में बदलना चाहिए, चार को सांकेतिक शब्दों में बदलना करने के लिए चुना गया चैनल मनमाना है।
• अन्य आरजीबी रंगों के चैनलों को बेतरतीब ढंग से तैयार किया जाना चाहिए, इसके अलावा आप जिस स्ट्रिंग को एन्कोड करना चाहते हैं, उसके अलावा; इसका अर्थ है कि आपके अंतिम गैर-एन्कोडेड चैनलों को 0x0000-0xFFFF(बेतरतीब ढंग से चुने गए) के बीच होना चाहिए ।
• अंतिम परिणाम को आरजीबी रंग मानों के 2 डी सरणी के रूप में व्यक्त करना ठीक है 0x000000-0xFFFFFF, छवि निर्माण का उपयोग करने की आवश्यकता नहीं है जब तक कि आप इसके साथ मज़े नहीं करना चाहते हैं या यदि यह कम बाइट्स है। यदि आप हेक्स स्ट्रिंग्स के रूप में आउटपुट चुनते हैं, तो #ईजी के साथ हेक्स स्ट्रिंग को उपसर्ग करें #FFFFFFया #05AB1E। आप टैब, अल्पविराम, या कुछ और के साथ अलग हो सकते हैं जो क्षैतिज रूप से समझदार होगा, लेकिन इसे वर्ग पैटर्न को बनाए रखना होगा; दूसरे शब्दों में, आपको उपयुक्त न्यूलाइन पृथक्करण का उपयोग करना चाहिए।
• आउटपुट एक वर्ग में होना चाहिए, और स्ट्रिंग को इसे बंद करने के लिए अंत में रिक्त स्थान के साथ गद्देदार होना चाहिए। इसका मतलब है कि N≈SQRT(Input#Length())। यदि इनपुट लंबाई एक पूर्ण वर्ग नहीं है, तो आपको Nरिक्त स्थान के साथ और पैड पर गोल होना चाहिए ।
• जैसा कि पहले कहा गया है, यदि आप छवि में रिक्त स्थान के साथ पैडिंग कर रहे हैं, तो आपको अंतिम "डिक्रिप्टेड" आउटपुट में गद्देदार वर्णों को शामिल नहीं करना चाहिए।
• आप मान सकते हैं कि:
  • इनपुट स्ट्रिंग रिक्त स्थान के साथ समाप्त नहीं होगी।
  • इनपुट स्ट्रिंग केवल मुद्रण योग्य ASCII वर्णों का उपयोग करेगी।
• यह कोड-गोल्फ है , सबसे कम बाइट काउंट जीतता है।

Comments

बस स्पष्ट करने के लिए, समाधानों को प्रति पिक्सेल वास्तव में एक वर्ण को एनकोड / डिकोड करना होगा ?

— ETHproductions

@ETHproductions जो एक अच्छी अनुवर्ती चुनौती की तरह लगता है, लेकिन इस प्रतियोगिता के उद्देश्य के लिए, आप एक एन्कोडिंग चैनल चुनते हैं और प्रति पिक्सेल 1 वर्ण को एनकोड करते हैं।

— मैजिक ऑक्टोपस Urn

मैं शायद इसका उपयोग नहीं करने जा रहा हूं, लेकिन क्या यह आवश्यक से अधिक रिक्त स्थान वाली छवि को "ओवरपैड" करने के लिए ठीक है? और क्या यह मान लेना ठीक है कि छवि में उतनी ही अधिक मात्रा होगी जो एनकोडर उत्पन्न करेगा?

@ ais523 मैं यह नहीं देख सकता कि इस प्रकार का तरीका कुछ भी करेगा लेकिन इसे लागू करने के लिए अधिक बाइट्स की आवश्यकता होगी। मैं इसके साथ नहीं जा रहा हूं, क्योंकि इस तरह के बड़े बदलाव करने के लिए चुनौती बहुत पुरानी है।

— मैजिक ऑक्टोपस Urn

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

Answer 1

05AB1E , 34 + 12 = 46 बाइट्स

लाल चैनल का उपयोग करता है।
05AB1E CP-1252 एन्कोडिंग का उपयोग करता है ।

एनकोड:

DgDtî©n-Äð×JvyÇh`4F15Ý.Rh«}})'#ì®ä

D                                   # duplicate input
 gDtî©n-Ä                           # abs(len(input)-round_up(sqrt(len(input)))^2)
         ð×J                        # join that many spaces to end of input
            v                       # for each char in string
             yÇ                     # get ascii value
               h`                   # convert to base-16 number
                 4F                 # 4 times do:
                   15Ý.Rh           # push random base-16 number
                         «          # concatenate
                          }}        # end inner and outer loop
                            )       # wrap in list
                             '#ì    # prepend a "#" to each element in list
                                ®ä  # split in pieces round_up(sqrt(len(input))) long

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

डिकोड:

˜vy3£¦HçJ}ðÜ

˜               # deep flatten input to a list
 v              # for each color in the list
  y3£           # take the first 3 chars
     ¦          # remove the hash sign
      H         # convert from base-16 to base-10
       ç        # get the ascii char with that value
        J       # join to string
         }      # end loop
          ðÜ    # remove trailing spaces

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

वैकल्पिक बाइटिंग पद्धति बराबर बाइट-काउंट के साथ

Dgð×J¹gtî©n£

Comments

मुझे लगता है कि आपको सवाल के अनुसार विशेष रूप से नई कहानियों में शामिल होना होगा? (आपका जवाब संभवतः मेरी पिटाई कर देगा, भले ही वह ऐसा करने के लिए अनुकूलित हो, हालांकि, क्योंकि मैंने केवल पांच बाइट बिताए हैं जो प्रश्न के उस हिस्से से निपटते हैं, और आप इससे भी आगे हैं।)

@ ais523: नियम बताता है कि 2D सरणियाँ ठीक थीं। क्या मुझे यह गलतफहमी थी कि किसी तरह?

— एमिग्ना

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

@ ais523: मैंने ओपी से स्पष्टीकरण मांगा है। जैसा कि आप कहते हैं, यह लागू करने के लिए एक बड़ा बदलाव नहीं है, लेकिन शायद कुछ बाइट्स को आप सहेज सकते हैं यदि स्वरूपण की आवश्यकता नहीं है।

— Emigna

@ ais523 या तो रास्ता स्वीकार्य है।

— मैजिक ऑक्टोपस Urn

Answer 2

सी, 201 (एनकोडिंग) + 175 (डिकोडिंग) = 376 बाइट्स

एनकोड करने के लिए:

E(char*J){size_t L=ceil(sqrt(strlen(J)));int U;srand(time(NULL));for(int i=0;i<L;i++){for(int f=0;f<L;f++){printf("#%02X%02X%02X ",rand()%256,(U<strlen(J))?(int)J[U]:32,rand()%256);U+=1;}printf("\n");}}

दो अन्य चैनलों को यादृच्छिक हेक्स मान के रूप में सेट करते समय आरजीबी स्पेक्ट्रम के हरे चैनल में इनपुट स्ट्रिंग के प्रत्येक चरित्र को एन्कोड करता है। एक स्ट्रिंग के रूप में एसटीडीआईएन के माध्यम से इनपुट लेता है और एक वर्ग के आकार में हेक्स रंग कोड के बहुस्तरीय स्ट्रिंग को आउटपुट करता है। मान लें कि आपके पास पायथन 3 और ImageMagick स्थापित है, और उपरोक्त फ़ाइल को a.outवर्तमान कार्य निर्देशिका (CWD) में नामित फ़ाइल में संकलित किया गया है , तो आप Output.pngनिम्नलिखित कमांड का उपयोग करके पाठ आउटपुट से CWD तक परिणामी छवि, नाम प्राप्त कर सकते हैं :

./a.out "<Multiline Input>"|python3 -c "import sys,subprocess;Input=sys.stdin.read();print('# ImageMagick pixel enumeration: {0},{0},255,rgb\n'.format(len(Input.split('\n')[1].split()))+'\n'.join(['%d,%d:(%d,%d,%d)'%(g,i,int(j[1:][:2],16),int(j[1:][2:4],16),int(j[1:][4:6],16))for g,h in enumerate(Input.split('\n'))for i,j in enumerate(h.split())]))"|convert - -scale 1000% Output.png

यहाँ Programming Puzzles and Code Golfइनपुट स्ट्रिंग के रूप में उपरोक्त कमोड द्वारा बनाई गई एक नमूना आउटपुट छवि है :

डिकोड करने के लिए:

D(int c,char**U){char T[c];for(int Y=1;Y<c;Y++){char G[2]={U[Y][3],U[Y][4]};T[Y-1]=(char)strtol(G,NULL,16);}int C=c-1;T[C]='\0';while(T[C]==' '){T[C]='\0';C-=1;}printf("%s\n",T);}

डबल उद्धरण में संलग्न (हर एक के साथ अंतरिक्ष से अलग किए हेक्स रंग कोड तार का एक अनुक्रम STDIN के माध्यम से इनपुट लेता है "() char** argvमें main) है और यह भी, जब में कहा जाता है main, int argcपूर्णांक इनपुट के लिए। डीकोड किए गए संदेश का प्रतिनिधित्व करने वाले एकल / बहु-पंक्ति स्ट्रिंग के उत्पादन के लिए।

जब भी और जहां भी मैं कर सकता हूं, मैं समय के साथ उन्हें और अधिक गोल्फ देने की कोशिश करूंगा।

---

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

int main(int argc,char**argv){if(strcmp(argv[1],"E")==0){Encode(argv[2]);}else{Decode(argc,argv);}}

और इसका उपयोग करते हुए, एन्कोडिंग के लिए आपको Eपहले तर्क के रूप में एकल स्ट्रिंग तर्क के बाद एन्कोडिंग विधि को कॉल करने के लिए प्रदान करना होगा , जबकि डिकोडिंग के लिए, आपको सभी प्रदान करने की आवश्यकता है, जो अंतरिक्ष में अलग-अलग हेक्स रंग कोड के साथ प्रत्येक में संलग्न है। डबल-कोट्स ( ")।

---

अंत में, यदि आप चाहें, तो आप पूरी तरह से तैयार, तैयार-से-उपयोग संस्करण यहां प्राप्त कर सकते हैं , हालांकि यह गोल्फ नहीं है, लेकिन संकलन पर किसी भी चेतावनी या त्रुटियों का उत्पादन नहीं करता है ।

Answer 3

पायथन 2, 164 160 + 94 93 = 253 बाइट्स

गेहूं विज़ार्ड के लिए 1 + 1 बाइट का धन्यवाद।

-5 बाइट्स काडे के लिए धन्यवाद

एनकोडर: स्ट्रिंग को उद्धरणों में संलग्न किया जाना चाहिए, उदाहरण के लिए "CodeGolf", आउटपुट एक रंग एएससीआई पीपीएम छवि है।

from random import*
s=input()
n=int((len(s)-1)**0.5)+1
s=s.ljust(n*n)
r=randint
print"P3 %d %d 255 "%(n,n)+''.join("%d "*3%(r(0,255),r(0,255),ord(c))for c in s)

विकोडक: इनपुट फ़ाइल नाम को कमांड लाइन तर्क के रूप में लेता है

from sys import*
print''.join(chr(int(c))for c in open(argv[1]).read().split()[6::3]).strip()

उपयोग:

 python golf_stegansquare_enc.py > stega.ppm

 python golf_stegansquare_dec.py stega.ppm

उदाहरण:

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ

लोरम इप्सम डोलर अमेट, कंसेटेटुर सेपसिटिंग एलीट, सेड डायम नॉनमी ईरमॉड अस्थायी इनविदंट यूट लैबर एट डोलोर मैग्ना एलिकयम एराट, सेड डायम वोलुपटुआ। एट ईओस एट एक्टसम एट जस्टो डुओ डोलोर्स एट ई रिबम। Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor सिट अमेट। लोरम इप्सम डोलर अमेट, कंसेटेटुर सेपसिटिंग एलीट, सेड डायम नॉनमी ईरमॉड अस्थायी इनविदंट यूट लैबर एट डोलोर मैग्ना एलिकयम एराट, सेड डायम वोलुपटुआ। एट ईओस एट एक्टसम एट जस्टो डुओ डोलोर्स एट ई रिबम। Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor सिट अमेट।

Comments

आप नज़दीकी for

— पार्न

@ETHproductions: sqrt (25-1) = sqrt (24) <5 और> 4. इसमें intसे 4 है जो तब +1एड है, इसलिए 5

— कार्ल नेप

ओह, मेरा बुरा, मैंने नहीं देखा -1।

— ETHproductions

आप डिकोडर में printऔर उसके बीच की जगह को हटा सकते हैं '। मुझे पूरा यकीन है कि आप int((len(s)+1)**.5)कुछ बाइट्स बचा सकते हैं ।

— Kade

मैं अपनी पिछली टिप्पणी के अंतिम वाक्य को फिर से लिख रहा हूं , हालांकि आप बदल ' '.join("%d %d %d"कर मुद्रण को छोटा कर सकते हैं ''.join(3*"%d "क्योंकि मुझे पूरा यकीन है कि एक अनुगामी स्थान ठीक है।

— काडे

Answer 4

स्काला, 97 + 68 = 165 बाइट्स

एन्क्रिप्शन (97 बाइट्स):

s=>s.map(_+((math.random*65535).toInt<<8)).iterator.grouped(math.sqrt(s.size)toInt)withPadding 32

स्ट्रिंग लेता है और इंटेगर के अनुक्रमों के एक Iterator को फिर से लिखता है।

डिक्रिप्शन (68 बाइट्स):

a=>" +$".r.replaceAllIn(a.flatten.map(h=>(h&0xFF)toChar)mkString,"")

इंटेगर के अनुक्रमों का एक आइटरेटर लेता है और एक स्ट्रिंग लौटाता है।

स्पष्टीकरण:

s=>                         //define an anonymous function
  s.map(                      //map each char of the string
    _+(                         //to the ascii value plus
      (math.random*65535).toInt)  //a random integer between 0 and 65535
      <<8                         //shifted 8 bits to the left
    )
  )
  .iterator                     //create an iterator
  .grouped(                     //group them in groups of size...
    math.sqrt(s.size)toInt        //sqrt of the size of the input, rounded up
  )withPadding 32               //pad with spaces to make a square

।

a=>
  " +$"              //take this string
  .r                 //parse it as a regex
  .replaceAllIn(     //replace every occurence of the regex in...
    a.flatten          //a flattened
    .map(h=>           //each element mapped
      (h&0xFF)toChar)    //to the character of the lower 8 bits
    mkString,          //joined to a string
    ""               //with an empty string
  )

Answer 5

पर्ल, (103 + 1) + (36 + 2) = 142 बाइट्स

छवि एनकोडर पर पाठ ( -p1-बाइट पेनल्टी के लिए रन करें ; -p0(दंड के अतिरिक्त बाइट के लिए) आवश्यक है यदि आप इनपुट स्ट्रिंग में नईलाइन्स को हैंडल करना चाहते हैं):

$_.=$"while($a=(length)**.5)=~/\./;$_=unpack"H*";s/../sprintf"#%04x$&,",rand+4**8/eg;s/(.*?\K,){$a}/
/g

टेक्स्ट डिकोडर के लिए छवि ( -p02-बाइट पेनल्टी के साथ चलाएं ):

$\.=chr hex for/..\W/g;$\=~s/ *$//}{

यह #abcdefटेक्स्ट-आधारित छवि प्रारूप का उपयोग करता है , और ब्लू चैनल में एन्कोड करता है। यहां Programming Puzzles and Code Golfइनपुट के रूप में दिए गए संभावित आउटपुट का एक उदाहरण दिया गया है:

# B4d250, # bccb72, # 43f06f, # 4d6767, # 74ba72, # 269,461
# E4f26d, # f63d6d, # 701c69, # bbf56e, # 6ef967, # d78d20
# 4e0d50, # 9b2775, # afd37a, # 12a47a, # 63e46c, # 0e9565
# 4cad73, # e43420, # 6da761, # 5a306e, # 8fba64, # 58f720
# D52443, # b4446f, # fbaf64, # 4a4365, # 1a5020, # f3ea47
# 354c6f, # 52cb6c, # 11a766, # 4c380a, # 553,820, # b31120

एनकोडर की व्याख्या:

$_.=$"             # append a space ($") to the input ($_)
  while            # as long as the following condition holds:
(($a=length)**.5)  # the square root of the input length (save this in $a)
=~/\./;            # has no decimal points in its string represenation
$_=unpack"H*";     # convert the input from base-256 to hexadecimal
s/../              # replace two characters of the input
  sprintf          # with a string formed from the template
  "#%04x$&,",      # four hex digits, the two matched characters, and a comma
  rand+4**8        # those hex digits are a random number from 0 to 4**8 (= 65536)
/eg;               # and do this for every non-overlapping match
s/(.*?             # find the minimum number of characters needed to match
   \K,)            # replacing the part of the match after the last matched comma
  {$a}/            # a string containing $a commas
/gx                # with a newline, for every non-overlapping match

मैं वास्तव में \Kकाम के इस उपयोग से खुश था ; यह निर्दिष्ट करता है कि कहां बदलना है, और इसे एक लूप के अंदर रखना, ऐसा लगता है कि अंतिम लूप पुनरावृत्ति पर घटना है जो मायने रखता है। तो s/(.*?\K,){$a}/\n/gकम से कम लंबाई के स्ट्रिंग से मेल खाएगा कुछ भी कॉमा कुछ भी कॉमा ... कुछ भी कॉमा, जिसमें $aकॉमा है, लेकिन मैच का वास्तविक बदला हुआ हिस्सा बस आखिरी कॉमा होगा। इसमें प्रत्येक $aवें अल्पविराम को एक नई रेखा के साथ बदलने का प्रभाव है , जिससे हमें छवि के लिए चौकोर आकार मिलता है।

इस चुनौती के लिए पर्ल का बड़ा फायदा (बिल्ट-इन-कैरेक्टर स्ट्रिंग-टू-हेक्साडेसिमल कनवर्टर के अलावा, जो अविश्वसनीय रूप से सुविधाजनक था) यह है कि इसमें एक बहुत छोटा डिकोडर है (इतना कम, वास्तव में, हालांकि पर्ल का एक बिल्डिन है) हेक्साडेसिमल को एक स्ट्रिंग में परिवर्तित करना, इसका उपयोग न करने के लिए कम था)। यहां देखिए यह कैसे काम करता है:

$\.=chr      # append to $\ the character code
  hex        # of the hexadecimal-string-to-number-translation
for/..\W/g;  # of each two characters that appear before a
             # non-alphanumeric character (not counting overlapping matches)
$\=~s/ *$//  # delete all spaces at the end of $\
}{           # in this context, this means "implicitly print $\,
             # prevent any other implicit printing"

गैर-अल्फ़ान्यूमेरिक वर्ण के ठीक पहले दो वर्णों का एकमात्र उदाहरण ब्लू चैनल (जिसे हम अनपैक करना चाहते हैं), जो कि कॉमा और न्यूलाइन्स से ठीक पहले दिखाई देते हैं; और दो अक्षर जो पहले के #मुकाबले एक दूसरे से पहले दिखाई देते हैं । हम मैचों की बाद वाली श्रेणी नहीं चाहते हैं, लेकिन वे अनिवार्य रूप से पूर्व श्रेणी को ओवरलैप करते हैं, और इस तरह ओवरलैपिंग मैचों की जांच से बाहर रखा जाएगा।

Answer 6

MySQL, 438 + 237 = 675 बाइट्स

आउटपुट के अंत में एक अनुगामी नई रेखा होती है, लेकिन यह डिक्रिप्ट होने के बाद दिखाई नहीं देती है। हेक्स फ़ंक्शन (पूर्णांक अधिभार) अग्रणी 0 को काट देगा, इसलिए मुझे इसे एक स्ट्रिंग के साथ पैड करना होगा। 0. अगर मैं सीमांकक के बीच दोनों फ़ंक्शन की घोषणा कर सकता हूं तो मैं कुछ बाइट्स बचा सकता हूं।

एन्क्रिप्ट

delimiter //create function a(i text)returns text begin declare r int;declare q,p text;while mod(length(i),sqrt(length(i)))<>0 do set i:=concat(i,' ');end while;set r:=1;set q:="";while r<=length(i) do set p:=",";if mod(r,sqrt(length(i)))=0 then set p:="\r\n";end if;set q:=concat(q,'#',right(concat(0,hex(floor(rand()*256))),2),right(concat(0,hex(floor(rand()*256))),2),hex(mid(i,r,1)),p);set r:=r+1;end while;return q;end//
delimiter ;

डिक्रिप्ट

delimiter //create function b(i text)returns text begin declare x int;declare y text;set x:=0;set y:="";while instr(i,'#')>0 do set i:=substr(i,instr(i,'#')+5);set y:=concat(y,unhex(left(i,2)));end while;return trim(y);end//
delimiter ;

उपयोग:

select a('test')
select b('#7D1874,#FFB465')
select b(a('test'))

Answer 7

सी #, 312 + 142 = 454 बाइट्स

एन्कोडिंग:

using System;I=>{var r=new Random();int i=I.Length;int N=(int)Math.Floor(Math.Sqrt(i))+1,S=N*N;while(i++<S){I+=' ';}var R="";for(i=0;i<S;){R+=i%N<1&i>0?"\n":i<1?"":" ";R+="#"+r.Next(256).ToString("X").PadLeft(2,'0')+r.Next(256).ToString("X").PadLeft(2,'0')+((int)I[i++]).ToString("X").PadLeft(2,'0');}return R;};

डिकोडिंग:

using System;I=>{var s=I.Replace('\n',' ').Split(' ');var R="";foreach(var t in s)R+=(char)System.Convert.ToInt32(t[5]+""+t[6],16);return R.TrimEnd(' ');};

पूरा कार्यक्रम:

using System;
class Steganographic
{
    static void Main()
    {
        Func<string, string> E = null;
        Func<string, string> D = null;

        E=I=>
        {
            var r=new Random();
            int i=I.Length;
            int N=(int)Math.Floor(Math.Sqrt(i))+1,S=N*N;
            while(i++<S){I+=' ';}
            var R="";
            for(i=0;i<S;)
            {
                R+=i%N<1&i>0?"\n":i<1?"":" ";
                R+="#"+r.Next(256).ToString("X").PadLeft(2,'0')+r.Next(256).ToString("X").PadLeft(2,'0')+((int)I[i++]).ToString("X").PadLeft(2,'0');
            }
            return R;
        };

        D=I=>
        {
            var s=I.Replace('\n',' ').Split(' ');
            var R="";
            foreach(var t in s)
                R+=(char)Convert.ToInt32(t[5]+""+t[6],16);
            return R.TrimEnd(' ');
        };

        string encoded = E("Programming Puzzles and Code Golf");
        Console.WriteLine(encoded);
        Console.WriteLine(D(encoded));

        encoded = E("Hello, World!");
        Console.WriteLine(encoded);
        Console.WriteLine(D(encoded));

        Console.Read(); // For Visual Studio
    }
}

Answer 8

गणितज्ञ, 111 + 65 = 176 बाइट्स

एनकोडर

Join[255~RandomInteger~{n=⌈Sqrt@Length@#⌉,n,2},ArrayReshape[#,{n,n,1},32],3]~Image~"Byte"&@*ToCharacterCode

डिकोडर

StringTrim[""<>FromCharacterCode@ImageData[#,"Byte"][[;;,;;,3]]]&

Answer 9

प्रसंस्करण, 220 209 194 + 171 167 151 = 391 380 376 361 345 बाइट्स

अपडेट करें:

बेकार को हटा दिया noStroke()और दोनों को एक-बयान देने वाले छोरों के लिए बनाया।

बेकार हटा image(p,0,0);दिया, डिक्रिप्टर को पैरामीटर के रूप में फाइलनेम दिया

एन्क्रिप्शन एल्गोरिथम

void g(String h){int s=ceil(sqrt(h.length()));for(int y=0,x;y<s;y++)for(x=0;x<s;rect(x,y,1,1),x++)stroke(h.length()>y*s+x?h.charAt(y*s+x):32,random(255),random(255));get(0,0,s,s).save("t.png");}

फ़ंक्शन को कॉल करना: g("Programming Puzzles and Code Golf");

यह एक फ़ंक्शन है जो स्ट्रिंग में लेता है, और आउटपुट बनाता है, इसे सहेजने से पहले t.png। यह redछिपे हुए पाठ को संग्रहीत करने के लिए मान का उपयोग करता है ।

डिक्रिप्शन एल्गोरिथम

void u(String f){PImage p=loadImage(f);f="";for(int j=0,i;j<p.height;j++)for(i=0;i<p.width;i++)f+=(char)red(p.get(i,j));print(f.replaceAll(" +$",""));}

कॉल फ़ंक्शन द्वारा: u(file_name);

यह भी एक फ़ंक्शन है जो पैरामीटर द्वारा निर्दिष्ट छवि की खोज करता है, और फिर छिपे हुए स्ट्रिंग को आउटपुट करता है (क्योंकि यह स्ट्रिंग वापस करने से कम है)।

विस्तारित कोड

(एन्क्रिप्शन एल्गोरिथम)

void g(String h) {
  int s=ceil(sqrt(h.length()));
  for(int y=0,x;y<s;y++)
    for(x=0;x<s;rect(x,y,1,1),x++)
      stroke(h.length()>y*s+x?h.charAt(y*s+x):32,random(255),random(255));
  get(0,0,s,s).save("t.png");
}

फ़ंक्शन को कॉल करने पर स्ट्रिंग को पास किया जाता है। फ़ंक्शन की पहली पंक्ति ceilअपने वर्गमूल को लेते हुए वर्ग की ओर की लंबाई की गणना करती है । फिर हम एक फॉर-लूप में प्रवेश करते हैं, जहां हम stroke(एज का रंग) सेट करते हैं, वर्ण के ASCII मान को लाल और नीले और हरे रंग के लिए यादृच्छिक मान रखते हैं। ऐसा करने के बाद, हम rectचौड़ाई = 1और ऊंचाई = 1, यानी पिक्सेल (कुछ अजीब कारण के लिए, मैं pointठीक से नहीं पढ़ सकता) के साथ एक (आयत) बनाते हैं । अंतिम पंक्ति में, परिणामस्वरूप छवि को तब सहेजा जाता है t.png।

(डिक्रिप्शन एल्गोरिथम)

void u(String f) {
  PImage p=loadImage(f);
  f="";
  for(int j=0,i;j<p.height;j++)
    for(i=0;i<p.width;i++)
      f+=(char)red(p.get(i,j));
  print(f.replaceAll(" +$",""));
}

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

---

एन्क्रिप्टेड चुनौती कच्चे पाठ:

Answer 10

जेली, जेली के कोडपेज में 40 + 20 = 60 बाइट्स

एनकोडर (पाठ → छवि):

”#;;ØHX¤¥4¡
»⁶x⁹²¤¤Ob⁴‘ịØHÇ€sj€”,Y
L½Ċç@

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

विकोडक (छवि → पाठ):

ḣ2ØHiЀ’ḅ⁴Ọ
ṣ”#Ç€œr⁶

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

एक उदाहरण आउटपुट प्रोग्राम का उत्पादन कर सकता है (यह लाल चैनल में जानकारी संग्रहीत करता है):

#504219,#720200,#6F38F1,#67055F,#7228C7,#61AC95
#6DD797,#6D20CB,#6962FA,#6E69B1,#67C41C,#209436
#50CB19,#75C9FC,#7A1B06,#7A695B,#6C5D5B,#6539A6
#735925,#20C80F,#612C38,#6EBF9E,#64C79E,#200915
#4337C5,#6F4704,#64FB5F,#65B2D1,#20E075,#47BC7C
#6F0C16,#6CD8EF,#66060B,#203C6C,#20D6E9,#20C0D7

इन बड़ी चुनौतियों में, जेली की थकावट थोड़ी दूर होने लगती है, जिससे कई "संरचनात्मक" पात्रों को पार्सिंग अस्पष्टता को हल करने की आवश्यकता होती है, लेकिन फिर भी यह बहुत ही जटिल है। यहां बताया गया है कि एनकोडर कैसे काम करता है:

Subroutine 1: convert digits to randomly padded hex string
”#;;ØHX¤¥4¡
”#;                     prepend #
    ØHX                 random hexadecimal digit
       ¤                parse ØH and X as a unit
   ;                    append
        ¥               parse ; and ØHX¤ as a unit
         4¡             repeat four times

Subroutine 2: convert string λ to square with size ρ
»⁶x⁹²¤¤Ob⁴‘ịØHÇ€sj€”,Y
 ⁶                      space
   ⁹²                   ρ squared
     ¤                  parse ⁹² as a unit
  x                     repeat string (i.e. ρ² spaces)
      ¤                 parse ⁶x⁹²¤ as a unit
»                       take maximum
Because space has the lowest value of any printable ASCII character,
this has the effect of padding λ to length ρ² with spaces.
       O                take codepoints of string
        b⁴              convert to base 16
           ịØH          use as indexes into a list of hexadecimal digits
          ‘             0-indexed (Jelly uses 1-indexing by default)
              ǀ        run subroutine 1 on each element
                s       split into groups of size ρ
                  €     inside each group
                 j ”,   join on commas
                     Y  join on newlines

Main program: basically just calculates ρ and lets subroutine 2 do the work
L½Ċç@
L                       length of input
 ½                      square rooted
  Ċ                     rounded up to the next highest integer
   ç@                   call subroutine 2 with the original input and the above

और यहां बताया गया है कि डिकोडर कैसे काम करता है:

Subroutine: convert hexadecimal color string (without #) to character
ḣ2ØHiЀ’ḅ⁴Ọ
ḣ2                      take first two characters
  ØHi                   find indexes in a string of hexadecimal digits
     Ѐ                 for each of those characters
       ’                0-indexed (Jelly uses 1-indexing by default)
        ḅ⁴              convert from base 16
          Ọ             convert integer to character

Main program:
ṣ”#Ç€œr⁶
ṣ”#                     split on # signs
   ǀ                   run the subroutine for each element
     œr⁶                remove spaces from the right