ट्यूपर सूत्र और पायथन में एल्गोरिदम का कार्यान्वयन

इसके बजाय अग्रदूत

ऐसा नहीं है बहुत पहले इंटरनेट खुला एक सूत्र Tupper के रूप में बेबीलोन लाइब्रेरी के इस तरह के एक अद्भुत और अद्भुत प्रतियों की सीखा रिक्त स्थान पर। बल्कि, यह सूत्र की तुलना में ट्यूपर की असमानता अधिक है। इस असमानता की ख़ासियत यह है कि यह चार्ट पर अपनी छवि बनाता है। जरा इस चमत्कार को देखिये!



(विकिपीडिया स्रोत)

छवि में जो आप देख रहे हैं, वही जेफ ट्यूपर का सूत्र है। संभवतः, आधे पाठक पहले ही इस असमानता का परिणाम निकालने के लिए टंगस्टन में जा चुके हैं ... लेकिन यह इतना सरल नहीं है। जैसा कि आप इस छवि में देख सकते हैं, ग्राफ पर सूत्र अक्ष ओए [के; के साथ एक खंड पर देखा जा सकता है; k + १५]। यह रहस्यमय संख्या k क्या है? कहां से लाएं? बात यह है कि बेबीलोनियन लाइब्रेरी की अवधारणा के अनुसार यह असमानता, 106x17 के संकल्प के साथ बिल्कुल किसी भी छवि को प्रदर्शित कर सकती है! ग्राफ पर प्रत्येक छवि की अपनी स्थिति है, जिसमें एक अद्वितीय संख्या k है। इस प्रकार, प्रत्येक संख्या k के लिए पूरे ग्राफ पर एक एकल छवि है !

किसी दिए गए चित्र के लिए, संख्या k इस प्रकार है:

4858450636189713423582095962494202044581400587983244549483093085061934704708809928450644769865524364849997247024915119110411605739177407856919754326571855442057210445735883681829823754139634338225199452191651284348332905131193199953502413758765239264874613394906870130562295813219481113685339535565290850023875092856892694555974281546386510730049106723058933586052544096664351265349363643957125565695936815184334857605266940161251266951421550539554519153785457525756590740540157929001765967965480064427829131488548259914721248506352686630476300

ऐसे लोगों को देखना दिलचस्प है जो सूत्र को देखने के लिए इस तरह के समन्वय पर स्क्रॉल करेंगे

यह मेरे लिए पाइथन 3 में एक प्रोग्राम लिखने के लिए हुआ जो एक छवि को नंबर k और इसके विपरीत में बदल देगा और आपको एक नंबर में एक छवि को एन्कोड करने के एक और शानदार तरीके के बारे में बताएगा।

सिद्धांत

(जोड़ा) यह कैसे काम करता है?

आइए सूत्र पर एक नज़र डालें:

आइए इसके सिंटैक्स को परिभाषित करें:
- संख्या नीचे हो गई
mod (x, y) - x को y से विभाजित करने का शेष

और फिर, ऐसा लगता है, सब कुछ स्पष्ट है।
ध्यान दें कि दोनों x और y नीचे हैं। यह वह दौर है जो अंततः हमें एक पिक्सेल छवि देता है


हर उस चीज़ को अस्वीकार करें जो असमानता के दाईं ओर गोल है $$$\ अल्फा$।
तो

$$

$$1/2 <[\ अल्फा] <=> 1 <= [\ अल्फा]$$

जो स्पष्ट है, क्योंकि पूरी अभिव्यक्ति नीचे है।

आज्ञा दें y = 17r + q, जहां r 17 से y को विभाजित करने का पूर्णांक भाग है, और r विभाजन के शेष भाग है। इस प्रकार, हम सूत्र में बदल सकते हैं $$$[y / 17]$आर पर, और $$$mod (y, 17)$क्ष पर।

हमें मिलता है

$$

$$1 <= mod (q * 2 ^ {- 17-आर}, 2)$$

वरना

$$

$$1 <= mod (q / 2 ^ {17x + r}, 2)$$

mod ( $$$\ अल्फा$, 2) 2 मान लेता है - 0 या 1. तदनुसार, यह असमानता कहेगी कि क्या संख्या $$$q / 2 ^ {17x + r}$यहां तक ​​कि या नहीं।

ध्यान दें कि छवि को क्रमशः अंतराल [N, N + 16] में देखा जाता है $$$q = [y / 17]$छवि की पूरी ऊंचाई पर स्थिर रहता है, जिसे संख्या r के बारे में नहीं कहा जा सकता है (संपूर्ण छवि में यह 0 से 16 तक भिन्न होता है)।

और अब केक पर चेरी। संख्या $$$[q / {2 ^ {17x + r}}]$अजीब होगा अगर और केवल अगर बिट संख्या (17x + r) क्यू के बाइनरी प्रतिनिधित्व में 1 के बराबर है। और चूंकि संख्या क्यू लगातार अपनी ऊंचाई और इसके बाइनरी प्रतिनिधित्व के साथ बदल रही है, हमें हर बार एक अनूठी छवि मिलती है! ठीक वैसा ही है, जो टेंपर का फॉर्मूला काम करता है।

अब देखते हैं कि जिस ऊंचाई पर हम अपनी छवि देखना चाहते हैं, उसकी गणना कैसे करें

संख्या k की गणना का सिद्धांत

ट्यूपर ने स्वयं किसी भी 106x17 छवि के लिए संख्या k की गणना का वर्णन किया (यह महत्वपूर्ण है!) निम्नानुसार है:

1. छवि को काले और सफेद में बदलें
2. प्रत्येक पिक्सेल को नीचे से ऊपर तक, बाएं से दाएं और बफ़र में पढ़ें। यदि पिक्सेल काला है - तो 1 डालें, यदि सफेद - 0।
3. बाइनरी को दशमलव में बदलें और 17 से गुणा करें
4. लाभ!

संख्या k से एक छवि प्राप्त करने के लिए, हम सब कुछ ठीक विपरीत करते हैं। ठीक है, चलो कोडिंग जाओ!

कोड

UPD: टिप्पणियों में, लोगों ने कोड में थोड़ा सुधार किया, इसे सरल और अधिक पारदर्शी बनाया। इस लेख ने अपडेट डेटा प्रकाशित किया है। यदि आप कोड के पुराने संस्करणों को देखना चाहते हैं - जीथब रिपॉजिटरी पर जाएं (जब तक आप इसे प्रतिबद्ध नहीं करते हैं, लेख के अंत में लिंक करें) और टिप्पणी में

K से छवि तक

युपीडी

टिप्पणीकारों के अनुरोध पर, इस असमानता और k का उपयोग करके छवि की गणना करने के लिए एक नया तरीका जोड़ा गया! अब हम संख्या के साथ जोड़तोड़ नहीं करेंगे, बाइनरी सिस्टम में स्थानांतरण करेंगे, लेकिन सीधे फ़ंक्शन को ही प्रभावित करेंगे!

नंबर k को डिकोड करने के लिए टैपर विधि का उपयोग करना

हमें उपयोगकर्ता से नंबर k मिलता है, उसकी आँखों को बंद करके हम इसे 17 से विभाजित करते हैं और इसे बाइनरी सिस्टम में अनुवाद करते हैं।

 def from_k_to_bin(k: int) -> list: k //= 17 binary = bin(k)[2:] 

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

 def from_k_to_bin(k: int) -> list: k //= 17 binary = bin(k)[2:] #   RadicalDreamer binary = ("0" * (1802 - len(binary))) + binary 

अगला, एक दो-आयामी सूची घोषित करें जिसमें हम छवि की प्रत्येक पंक्ति के बारे में जानकारी संग्रहीत करेंगे। फिर हम उन सभी बिट्स को लिखते हैं जो हम पढ़ते हैं (एल्गोरिथ्म को न भूलें जिसके द्वारा नंबर k बनाया जाता है - नीचे से ऊपर तक, बाएं से दाएं)

 lists = [[] for x in range(17)] #C   RadicalDreamer for x in range(1802): lists[-(x % 17)].append(binary[x]) <b> !</b> <source lang="python"> #-----!-----# image = Image.new("1", (106,17), (0)) # -  10617 draw = image.load() for y in range(17): for x in range(106): image.putpixel(xy=(105-x,16-y), value=(int(lists[y][x]),)) #    ,      lists image.save("image.png") #  

आइए नंबर k को पुश करने का प्रयास करें, जिसे मैंने लेख की शुरुआत में, हमारे कार्यक्रम में इंगित किया है और निम्नलिखित प्राप्त करें:



जैसा कि आप देख सकते हैं, सब कुछ हमारे लिए काम करता है, और अब हम किसी भी कश्मीर को डिकोड करने में सक्षम हैं!

K से चित्र बनाने के लिए असमानता का उपयोग करना

सबसे पहले, अजगर में फ़ंक्शन लिखें:

 def f(x,y): return ((y//17)//(1 << (17*x+(y%17))))%2 

// और << ऑपरेटरों के लिए धन्यवाद, फ़ंक्शन के कार्यान्वयन को बहुत सरल किया गया है। यह गारंटी है कि संख्या x और y पूर्णांक होंगे !

हम फिर से एक दो-आयामी सूची बनाते हैं, जहां हम छवि के बिट्स को संग्रहीत करेंगे और इसमें प्रत्येक पंक्ति के बारे में जानकारी लिखेंगे जिसमें लूप्स का उपयोग किया जाएगा

 lists = [[] for x in range(17)] for y in range(16,-1,-1): for x in range(105,-1,-1): lists[y].append(int(f(x,y+k) > 1/2)) 

और फिर, पिछले उदाहरण के रूप में, हम पीआईएल लाइब्रेरी का उपयोग करके एक चित्र बनाते हैं।

पूरा कार्य इस तरह दिखता है:

 def from_k_to_bin(k: int) -> list: lists = [[] for x in range(17)] for y in range(16,-1,-1): for x in range(105,-1,-1): lists[y].append(int(f(x,y+k) > 1/2)) return lists 

चित्र में k

खैर, अब हम किसी भी छवि को संख्या k में बदलना सीखेंगे।

पहले हम खुद ही छवि प्राप्त करते हैं

 def get_image() -> Image: name = input("   (      ):") try: im = Image.open(name) except Exception: print("!") exit(0) return im 

इसका आकार जांचें

 _SIZE_WIDTH = 106 _SIZE_HEIGHT = 17 image = get_image() width, height = image.size flag_okay = False if width == _SIZE_WIDTH and height == _SIZE_HEIGHT: flag_okay = True if not flag_okay: print("  ") print(width, height) exit(0) print(" !") 

हम छवि को काले और सफेद बनाते हैं और पिक्सेल द्वारा पिक्सेल पढ़ना शुरू करते हैं:

 image = image.convert('1') byteset = "" for x in range(105,-1,-1): for y in range(0,17): #c m03r   if image.getpixel((x,y)) > 127: byteset += '1' else: byteset += '0' 

यह केवल दशमलव प्रणाली में परिवर्तित होने और 17 से गुणा करने के लिए बना हुआ है।

 k = int(byteset,2)*17 print(" :") print(k) 

अच्छा, चलिए टेस्ट करते हैं!

मैंने हब्र लोगो को कोड करने का फैसला किया। यहाँ स्रोत छवि है:



हम कार्यक्रम शुरू करते हैं और छवि नाम निर्दिष्ट करते हैं:



हमें निम्नलिखित k मिला:

4858487703217654168507377107565676789145697178497253677539145555247620343537955749299116772611982962556356527603203744742682135448820545638134012705381689785851604674225344958377377969928942310236199337805399065932982909660659786056259547094494380793146587709009524498386724160055692719747815828234655968636671461350354316223620304956111171025410498514602810746287134775641383930152393933036921599511277388743068766568352667661462097979110006690900253037600818522726237351439443865433159187625289316917268254866954663750093103703327097252478959

आइए इसे हमारे स्वयं के कार्यक्रम पर देखें।

यहाँ हमें प्राप्त छवि है:



काले और सफेद रंग में छवि के थोड़े टेढ़े अनुवाद के कारण यह थोड़ा विकृत हो गया था।

परिणाम

स्रोत कोड: Github

स्रोत: विकी लेख