🚚 🍚 🎇 बेबीलोनियन पुस्तकालय का कार्यान्वयन 🕉️ 📃 🔧

इस लेख में आप बेबीलोन के पुस्तकालय के बारे में सब सीखेंगे, और सबसे महत्वपूर्ण बात यह है कि इसे फिर से कैसे बनाया जाए, और वास्तव में कोई भी पुस्तकालय।

आइए लुईस बोर्गेस के बेबीलोनियन लाइब्रेरी के उद्धरणों से शुरू करें।

उद्धरण

"ब्रह्मांड - कुछ इसे लाइब्रेरी कहते हैं - इसमें हेक्सागोनल दीर्घाओं की एक विशाल, संभवतः अनंत संख्या होती है, जिसमें व्यापक वायुमंडलीय कक्ष होते हैं, जो कम रेल द्वारा संलग्न होते हैं। प्रत्येक षट्भुज से दो ऊपरी और दो निचली मंजिलें दिखाई देती हैं - अनंत तक। "

“एक पुस्तकालय एक गेंद है, जिसका सटीक केंद्र हेक्सागोन्स में से एक में है, और सतह दुर्गम है। प्रत्येक षट्भुज की प्रत्येक दीवार पर पाँच अलमारियाँ होती हैं, प्रत्येक शेल्फ पर एक ही प्रारूप की बत्तीस पुस्तकें होती हैं, प्रत्येक पुस्तक में चार सौ और दस पृष्ठ होते हैं, प्रत्येक पृष्ठ में चालीस लाइनें होती हैं, प्रत्येक पंक्ति में लगभग अस्सी काले अक्षर होते हैं। पुस्तक की रीढ़ पर पत्र हैं, लेकिन वे यह परिभाषित नहीं करते हैं या पृष्ठ को क्या कहेंगे, इसका पूर्वाभास नहीं करते हैं। यह विसंगति, मुझे पता है, एक बार रहस्यमय लग रहा था। "

यदि आप एक यादृच्छिक षट्भुज में प्रवेश करते हैं, तो किसी भी दीवार पर जाएं, किसी भी शेल्फ को देखें और उस पुस्तक को लें जिसे आप सबसे अधिक पसंद करते हैं, तो आप सबसे अधिक परेशान हैं। आखिरकार, आपको वहां जीवन के अर्थ के बारे में जानने की उम्मीद थी, लेकिन आपने पात्रों के कुछ अजीब सेट देखे। लेकिन इतनी जल्दी परेशान मत होइए! अधिकांश पुस्तकें अर्थहीन हैं, क्योंकि वे पच्चीस वर्णों के सभी संभावित वेरिएंट की एक तलाशी वाली खोज हैं ( यह इस वर्णमाला है कि बोरेज ने अपने पुस्तकालय में उपयोग किया था, लेकिन तब पाठक को पता चलेगा कि लाइब्रेरी में किसी भी संख्या में वर्ण हो सकते हैं )। पुस्तकालय का मुख्य नियम यह है कि इसमें कोई दो बिल्कुल समान किताबें नहीं हैं, तदनुसार उनकी संख्या परिमित है, और पुस्तकालय भी किसी दिन समाप्त हो जाएगा। बोर्जेस का मानना था कि पुस्तकालय आवधिक है:

उद्धरण

“शायद डर और बुढ़ापा मुझे धोखा दे रहे हैं, लेकिन मुझे लगता है कि मानव जाति - केवल एक ही - विलुप्त होने के करीब है, और पुस्तकालय बच जाएगा: प्रबुद्ध, निर्जन, अनंत, बिल्कुल गतिहीन, कीमती संस्करणों से भरा, बेकार, अस्थिर, रहस्यमय। मैंने सिर्फ अंतहीन लिखा है। मैंने इस शब्द को बयानबाजी के लिए प्यार से दूर नहीं किया; मुझे लगता है कि यह मानना तर्कसंगत है कि दुनिया अंतहीन है। जो लोग इसे सीमित मानते हैं कि कहीं दूर के गलियारों, और सीढ़ियों और हेक्सागोन्स में किसी अज्ञात कारण से समाप्त हो सकते हैं - ऐसी धारणा बेतुकी है। जो लोग सीमाओं के बिना इसकी कल्पना करते हैं, वे भूल जाते हैं कि संभावित पुस्तकों की संख्या सीमित है। मैं इस सदियों पुरानी समस्या के ऐसे समाधान का प्रस्ताव देने का साहस करता हूं: पुस्तकालय असीम और आवधिक है। यदि शाश्वत पथिक किसी भी दिशा में यात्रा पर निकलता है, तो वह सदियों के बाद यह सत्यापित कर सकेगा कि एक ही किताबों को एक ही गड़बड़ी में दोहराया जाता है (जो कि दोहराया जाने पर क्रम - क्रम बन जाता है)। यह सुंदर आशा मेरे अकेलेपन को और उज्ज्वल करती है। ”

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

इस पुस्तकालय के कार्यान्वयन के साथ आगे बढ़ने से पहले, मैं आपको एक दिलचस्प तथ्य से आश्चर्यचकित कर दूंगा: यदि आप लुईस बोर्जेस के बेबीलोनियन पुस्तकालय को फिर से बनाना चाहते हैं, तो आप सफल नहीं होंगे, क्योंकि इसकी मात्रा दृश्यमान ब्रह्मांड की मात्रा 10 ^ 611338 (!) टाइम्स से अधिक है। और यहां तक कि बड़े पुस्तकालयों में क्या होगा, मैं यह सोचकर भी डर गया हूं।

पुस्तकालय कार्यान्वयन

मॉड्यूल विवरण

हमारा छोटा सा परिचय खत्म हो गया है। लेकिन यह बिना अर्थ के नहीं है: अब आप समझते हैं कि बेबीलोनियन पुस्तकालय क्या है, और पढ़ना केवल अधिक दिलचस्प होगा। लेकिन मैं मूल विचार से दूर हो जाऊंगा, मैं एक "सार्वभौमिक" पुस्तकालय बनाना चाहता था, जिस पर बाद में चर्चा की जाएगी। मैं Node.js. के तहत जावास्क्रिप्ट में लिखूंगा कि पुस्तकालय को क्या करने में सक्षम होना चाहिए?

जल्दी से वांछित पाठ ढूंढें और लाइब्रेरी में अपना स्थान प्रदर्शित करें
पुस्तक का शीर्षक परिभाषित करें
जल्दी से सही शीर्षक के साथ एक किताब खोजें

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

मुख्य फ़ाइल index.js है, लाइब्रेरी का पूरा तर्क वहां वर्णित है, मैं इस फ़ाइल की सामग्री को समझाऊंगा।

let sha512 = require(`js-sha512`);

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

 module.exports = ({ lengthOfPage = 4819, lengthOfTitle = 31, digs = '0123456789abcdefghijklmnopqrstuvwxyz', alphabet = ', .', wall = 5, shelf = 7, volume = 31, page = 421, } = {}) => { // ... };

अब हम मापदंडों पर चलते हैं। मानक संख्यात्मक मापदंडों के रूप में, मैंने अभाज्य संख्याओं को चुनने का फैसला किया, क्योंकि यह मुझे लगता था कि यह अधिक दिलचस्प होगा।

lengthOfPage - संख्या, एक पृष्ठ पर वर्णों की संख्या। डिफ़ॉल्ट 4819 है। यदि हम इस संख्या को कहते हैं, तो हमें 61 और 79 मिलते हैं। 79 वर्णों की 61 पंक्तियाँ, या इसके विपरीत, लेकिन मैं पहला विकल्प पसंद करता हूँ।
lengthOfTitle - संख्या, पुस्तक शीर्षक के शीर्षक में वर्णों की संख्या।
digs - एक स्ट्रिंग, इस स्ट्रिंग की लंबाई के बराबर आधार के साथ एक संख्या के संभावित अंक। यह संख्या किस लिए है? इसमें षट्भुज की संख्या (पहचानकर्ता) होगी जिसमें हम जाना चाहते हैं। डिफ़ॉल्ट रूप से, यह लैटिन और लोअरकेस 0-9 है। अधिकांश पाठ यहां एन्कोड किए गए हैं, इसलिए यह एक बड़ी संख्या होगी - कई हजार बिट्स (पृष्ठ पर वर्णों की संख्या के आधार पर), लेकिन यह चरित्र द्वारा संसाधित किया जाएगा।
वर्णमाला - स्ट्रिंग, अक्षर जिसे हम पुस्तकालय में देखना चाहते हैं। यह उनसे भरा जाएगा। सब कुछ सही ढंग से काम करने के लिए, वर्णमाला में वर्णों की संख्या स्ट्रिंग में वर्णों की संख्या के बराबर होनी चाहिए जो कि षट्भुज की पहचान करने वाली संख्या के संभावित अंकों के साथ हो।
दीवार - संख्या, अधिकतम दीवार संख्या, डिफ़ॉल्ट ५
शेल्फ - संख्या, अधिकतम शेल्फ संख्या, डिफ़ॉल्ट 7
वॉल्यूम - संख्या, अधिकतम पुस्तक संख्या, डिफ़ॉल्ट रूप से ३१
पृष्ठ - संख्या, अधिकतम पृष्ठ संख्या, डिफ़ॉल्ट ४२१

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

पृष्ठ खोज और एल्गोरिदम प्रदर्शित करें

जब हम किसी पते पर जाते हैं, तो हम पृष्ठ की सामग्री देखते हैं। यदि हम फिर से उसी पते पर जाते हैं, तो सामग्री बिल्कुल वैसी ही होनी चाहिए। पुस्तकालयों की यह संपत्ति छद्म आयामी संख्या पैदा करने के लिए एक एल्गोरिथ्म प्रदान करती है - रैखिक सर्वांगसम विधि । जब हमें पता उत्पन्न करने के लिए एक चरित्र का चयन करने की आवश्यकता होती है या, इसके विपरीत, पृष्ठ की सामग्री, तो यह हमारी मदद करेगा, और पृष्ठों की संख्या, अलमारियों, आदि का उपयोग अनाज के रूप में किया जाएगा। मेरे PRNG का विन्यास: m = 2 ^ 32 (4294967296), a = 22695477, c = 1. मैं यह भी जोड़ना चाहूंगा कि हमारे कार्यान्वयन में केवल संख्या का सिद्धांत रैखिक सर्वांगसम विधि से बना रहता है, बाकी को बदल दिया जाता है। हम कार्यक्रम की सूची को आगे बढ़ाते हैं:

कोड

 module.exports = ({ lengthOfPage = 4819, lengthOfTitle = 31, digs = '0123456789abcdefghijklmnopqrstuvwxyz', alphabet = ', .', wall = 5, shelf = 7, volume = 31, page = 421, } = {}) => { let seed = 13; //   const rnd = (min = 1, max = 0) => { //   //    min  max seed = (seed * 22695477 + 1) % 4294967296; //   //      return min + seed / 4294967296 * (max - min); //   //   }; const pad = (s, size) => s.padStart(size, `0`); //   //       let getHash = str => parseInt(sha512(str).slice(0, 7), 16); //  const mod = (a, b) => ((a % b) + b) % b; //    const digsIndexes = {}; //     //    digs const alphabetIndexes = {}; //     //    alphabet Array.from(digs).forEach((char, position) => { //    digs digsIndexes[char] = position; //     //   }); Array.from(alphabet).forEach((char, position) => { //    alphabet alphabetIndexes[char] = position; //     //   }); return { //    };

जैसा कि आप देख सकते हैं, संख्या की प्रत्येक प्राप्ति के बाद PRNG अनाज बदल जाता है, और परिणाम सीधे तथाकथित संदर्भ बिंदु पर निर्भर करते हैं - अनाज, जिसके बाद संख्याएं हमें रुचि देगी। (हम पता उत्पन्न करते हैं या पृष्ठ की सामग्री प्राप्त करते हैं)

GetHash फ़ंक्शन हमें एक संदर्भ बिंदु उत्पन्न करने में मदद करेगा। हमें बस कुछ डेटा से हैश मिलता है, 7 अक्षर लेते हैं, एक दशमलव संख्या प्रणाली में अनुवाद करते हैं और आपका काम हो गया!

मॉड फ़ंक्शन% ऑपरेटर के समान व्यवहार करता है। लेकिन अगर लाभांश <0 है (ऐसी स्थितियां संभव हैं), तो विशेष फ़ंक्शन के कारण मॉड फ़ंक्शन एक सकारात्मक संख्या लौटाएगा, हमें पते पर पेज की सामग्री प्राप्त करते समय वर्णमाला स्ट्रिंग से वर्णों का सही ढंग से चयन करने के लिए इसकी आवश्यकता है।

और मिठाई कोड का अंतिम टुकड़ा लौटी लाइब्रेरी ऑब्जेक्ट है:

कोड

 return { wall, shelf, volume, page, lengthOfPage, lengthOfTitle, search(searchStr) { let wall = `${(Math.random() * this.wall + 1 ^ 0)}`, shelf = `${(Math.random() * this.shelf + 1 ^ 0)}`, volume = pad(`${(Math.random()* this.volume + 1 ^ 0)}`, 2), page = pad(`${(Math.random()* this.page + 1 ^ 0)}`, 3), locHash = getHash(`${wall}${shelf}${volume}${page}`), hex = ``, depth = Math.random() * (this.lengthOfPage - searchStr.length) ^ 0; for (let i = 0; i < depth; i++){ searchStr = alphabet[Math.random() * alphabet.length ^ 0] + searchStr; } seed = locHash; for (let i = 0; i < searchStr.length; i++){ let index = alphabetIndexes[searchStr[i]] || -1, rand = rnd(0, alphabet.length), newIndex = mod(index + parseInt(rand), digs.length), newChar = digs[newIndex]; hex += newChar; } return `${hex}-${wall}-${shelf}-${+volume}-${+page}`; }, searchExactly(text) { const pos = Math.random() * (this.lengthOfPage - text.length) ^ 0; return this.search(`${` `.repeat(pos)}${text}${` `.repeat(this.lengthOfPage - (pos + text.length))}`); }, searchTitle(searchStr) { let wall = `${(Math.random() * this.wall + 1 ^ 0)}`, shelf = `${(Math.random() * this.shelf + 1 ^ 0)}`, volume = pad(`${(Math.random()* this.volume + 1 ^ 0)}`, 2), locHash = getHash(`${wall}${shelf}${volume}`), hex = ``; searchStr = searchStr.substr(0, this.lengthOfTitle); searchStr = searchStr.length == this.lengthOfTitle ? searchStr : `${searchStr}${` `.repeat(this.lengthOfTitle - searchStr.length)}`; seed = locHash; for (let i = 0; i < searchStr.length; i++){ let index = alphabetIndexes[searchStr[i]], rand = rnd(0, alphabet.length), newIndex = mod(index + parseInt(rand), digs.length), newChar = digs[newIndex]; hex += newChar; } return `${hex}-${wall}-${shelf}-${+volume}`; }, getPage(address) { let addressArray = address.split(`-`), hex = addressArray[0], locHash = getHash(`${addressArray[1]}${addressArray[2]}${pad(addressArray[3], 2)}${pad(addressArray[4], 3)}`), result = ``; seed = locHash; for (let i = 0; i < hex.length; i++) { let index = digsIndexes[hex[i]], rand = rnd(0, digs.length), newIndex = mod(index - parseInt(rand), alphabet.length), newChar = alphabet[newIndex]; result += newChar; } seed = getHash(result); while (result.length < this.lengthOfPage) { result += alphabet[parseInt(rnd(0, alphabet.length))]; } return result.substr(result.length - this.lengthOfPage); }, getTitle(address) { let addressArray = address.split(`-`), hex = addressArray[0], locHash = getHash(`${addressArray[1]}${addressArray[2]}${pad(addressArray[3], 2)}`), result = ``; seed = locHash; for (let i = 0; i < hex.length; i++) { let index = digsIndexes[hex[i]], rand = rnd(0, digs.length), newIndex = mod(index - parseInt(rand), alphabet.length), newChar = alphabet[newIndex]; result += newChar; } seed = getHash(result); while (result.length < this.lengthOfTitle) { result += alphabet[parseInt(rnd(0, alphabet.length))]; } return result.substr(result.length - this.lengthOfTitle); } };

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

खोज विधि

 search(searchStr) { let wall = `${(Math.random() * this.wall + 1 ^ 0)}`, shelf = `${(Math.random() * this.shelf + 1 ^ 0)}`, volume = pad(`${(Math.random() * this.volume + 1 ^ 0)}`, 2), page = pad(`${(Math.random() * this.page + 1 ^ 0)}`, 3), locHash = getHash(`${wall}${shelf}${volume}${page}`), hex = ``, depth = Math.random() * (this.lengthOfPage - searchStr.length) ^ 0; for (let i = 0; i < depth; i++){ searchStr = alphabet[Math.random() * alphabet.length ^ 0] + searchStr; } seed = locHash; for (let i = 0; i < searchStr.length; i++){ let index = alphabetIndexes[searchStr[i]] || -1, rand = rnd(0, alphabet.length), newIndex = mod(index + parseInt(rand), digs.length), newChar = digs[newIndex]; hex += newChar; } return `${hex}-${wall}-${shelf}-${+volume}-${+page}`; }

लायब्रेरी में searchStr स्ट्रिंग का पता देता है। ऐसा करने के लिए, बेतरतीब ढंग से दीवार, शेल्फ, वॉल्यूम, पेज का चयन करें। मात्रा और पृष्ठ भी इच्छित लंबाई के लिए शून्य के साथ गद्देदार। अगला, उन्हें getHash फ़ंक्शन में पास करने के लिए एक स्ट्रिंग में सम्मिलित करें। परिणामी लोकाश शुरुआती बिंदु है, अर्थात्। अनाज।

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

षट्भुज पहचानकर्ता उत्पन्न करने के लिए केवल एक चीज बची है खोज स्ट्रिंग स्ट्रिंग के प्रत्येक वर्ण के लिए, हम एल्गोरिथ्म को निष्पादित करते हैं:

वर्णमाला वर्णमाला ऑब्जेक्ट से वर्णमाला में सूचकांक वर्ण की संख्या प्राप्त करें। यदि यह नहीं है, तो -1 लौटें, लेकिन यदि ऐसा होता है, तो आप निश्चित रूप से कुछ गलत कर रहे हैं।
हमारे PRNG का उपयोग करके छद्म-यादृच्छिक संख्या रैंड उत्पन्न करें, वर्णमाला की लंबाई से 0 तक।
नए सूचकांक की गणना करें, जो कि प्रतीक सूचकांक की संख्या और छद्म-यादृच्छिक संख्या रैंड के योग के रूप में गणना की जाती है, मोडुलो को डिग्स की लंबाई से विभाजित करती है।
इस प्रकार, हमें षट्भुज पहचानकर्ता का अंक मिला - newChar (इसे डिग्स से लेना)।
नए पहचानकर्ता को हेक्स पहचानकर्ता से जोड़ें

हेक्स पीढ़ी के पूरा होने पर, हम उस स्थान का पूरा पता देते हैं जिसमें वांछित रेखा निहित होती है। पता घटकों को एक हाइफ़न द्वारा अलग किया जाता है।

SearchExactly विधि

 searchExactly(text) { const pos = Math.random() * (this.lengthOfPage - text.length) ^ 0; return this.search(`${` `.repeat(pos)}${text}${` `.repeat(this.lengthOfPage - (pos + text.length))}`); }

यह विधि खोज विधि के समान है, लेकिन सभी रिक्त स्थान को भरता है ( खोज स्ट्रिंग searchStr को लंबाई की लंबाई वाले अक्षरों से बनाता है) रिक्त स्थान। ऐसा पृष्ठ देखने पर, यह दिखाई देगा कि आपके पाठ के अलावा इस पर कुछ भी नहीं है।

SearchTitle विधि

 searchTitle(searchStr) { let wall = `${(Math.random() * this.wall + 1 ^ 0)}`, shelf = `${(Math.random() * this.shelf + 1 ^ 0)}`, volume = pad(`${(Math.random()* this.volume + 1 ^ 0)}`, 2), locHash = getHash(`${wall}${shelf}${volume}`), hex = ``; searchStr = searchStr.substr(0, this.lengthOfTitle); searchStr = searchStr.length == this.lengthOfTitle ? searchStr : `${searchStr}${` `.repeat(this.lengthOfTitle - searchStr.length)}`; seed = locHash; for (let i = 0; i < searchStr.length; i++){ let index = alphabetIndexes[searchStr[i]], rand = rnd(0, alphabet.length), newIndex = mod(index + parseInt(rand), digs.length), newChar = digs[newIndex]; hex += newChar; } return `${hex}-${wall}-${shelf}-${+volume}`; }

SearchTitle विधि searchStr नामक पुस्तक का पता देती है । अंदर, यह खोज करने के लिए बहुत समान है। अंतर यह है कि locHash की गणना करते समय हम इसका नाम पुस्तक में बाँधने के लिए उपयोग नहीं करते हैं। यह पृष्ठ पर निर्भर नहीं होना चाहिए। यदि आवश्यक हो तो searchStr को लंबाई में छोटा किया जाता है। इसी तरह, हेक्सागोन पहचानकर्ता उत्पन्न होता है और प्राप्त पता वापस कर दिया जाता है। कृपया ध्यान दें कि इसमें कोई पृष्ठ नहीं है, क्योंकि यह मनमाना पाठ के सटीक पते की खोज करते समय था। इसलिए यदि आप यह पता लगाना चाहते हैं कि आपके द्वारा गढ़े गए नाम के साथ पुस्तक में क्या है, तो उस पृष्ठ पर निर्णय लें जिस पर आप जाना चाहते हैं।

GetPage विधि

 getPage(address) { let addressArray = address.split(`-`), hex = addressArray[0], locHash = getHash(`${addressArray[1]}${addressArray[2]}${pad(addressArray[3], 2)}${pad(addressArray[4], 3)}`), result = ``; seed = locHash; for (let i = 0; i < hex.length; i++) { let index = digsIndexes[hex[i]], rand = rnd(0, digs.length), newIndex = mod(index - parseInt(rand), alphabet.length), newChar = alphabet[newIndex]; result += newChar; } seed = getHash(result); while (result.length < this.lengthOfPage) { result += alphabet[parseInt(rnd(0, alphabet.length))]; } return result.substr(result.length - this.lengthOfPage); }

खोज विधि के विपरीत। इसका कार्य पृष्ठ की सामग्री को निर्दिष्ट पते पर वापस करना है। ऐसा करने के लिए, हम विभाजक "-" का उपयोग करके पते को एक सरणी में परिवर्तित करते हैं। अब हमारे पास पता घटकों की एक सरणी है: षट्भुज पहचानकर्ता, दीवार, शेल्फ, पुस्तक, पृष्ठ। हम लोकहैश की गणना उसी तरह से करते हैं जैसे हमने खोज विधि में की थी। हमें वही नंबर मिलता है जो पता जनरेट करते समय था। इसका मतलब यह है कि PRNG एक ही संख्या का उत्पादन करेगा, यह यह व्यवहार है जो स्रोत पाठ पर हमारे परिवर्तनों की प्रतिवर्तीता सुनिश्चित करता है। इसकी गणना करने के लिए, हम प्रत्येक वर्ण (de facto, यह एक अंक है) पर षट्भुज पहचानकर्ता का एल्गोरिथ्म करते हैं:

हम स्ट्रिंग डिग्स में सूचकांक की गणना करते हैं। इसे digsIndexes से लें ।
PRNG का उपयोग करते हुए, हम एक बड़ी संख्या की संख्या प्रणाली के आधार के लिए रेंज 0 में एक छद्म-यादृच्छिक संख्या रैंड उत्पन्न करते हैं, इस सुंदर संख्या के अंकों वाले स्ट्रिंग की लंबाई के बराबर। सब कुछ स्पष्ट है।
हम स्रोत पाठ newIndex के प्रतीक की स्थिति की गणना सूचकांक और रैंड के बीच के अंतर के रूप में करते हैं, वर्णक्रम की लंबाई को विभाजित करते हैं। यह संभव है कि अंतर नकारात्मक है, फिर सामान्य विभाजन मोड्यूल एक नकारात्मक सूचकांक देगा, जो हमें सूट नहीं करता है, इसलिए हम मॉडुलो डिवीजन के एक संशोधित संस्करण का उपयोग करते हैं। (आप उपरोक्त सूत्र से निरपेक्ष मूल्य लेने के विकल्प की कोशिश कर सकते हैं, यह भी नकारात्मक संख्याओं की समस्या को हल करता है, लेकिन व्यवहार में यह अभी तक परीक्षण नहीं किया गया है)
पृष्ठ के पाठ का चरित्र नया है , हम वर्णमाला से सूचकांक प्राप्त करते हैं।
परिणाम में एक पाठ वर्ण जोड़ें।

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

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

GetTitle विधि

 getTitle(address) { let addressArray = address.split(`-`), hex = addressArray[0], locHash = getHash(`${addressArray[1]}${addressArray[2]}${pad(addressArray[3], 2)}`), result = ``; seed = locHash; for (let i = 0; i < hex.length; i++) { let index = digsIndexes[hex[i]], rand = rnd(0, digs.length), newIndex = mod(index - parseInt(rand), alphabet.length), newChar = alphabet[newIndex]; result += newChar; } seed = getHash(result); while (result.length < this.lengthOfTitle) { result += alphabet[parseInt(rnd(0, alphabet.length))]; } return result.substr(result.length - this.lengthOfTitle); }

खैर, कहानी वही है। पिछली विधि के वर्णन को पढ़ने की कल्पना करें, केवल तब जब PRNG अनाज की गणना पृष्ठ संख्या को ध्यान में नहीं रखते हैं, और परिणाम को पुस्तक शीर्षक की अधिकतम लंबाई - lengthOfTitle में जोड़ते हैं और काटते हैं ।

पुस्तकालयों के निर्माण के लिए मॉड्यूल का परीक्षण करना

बाद में हमने किसी बेबीलोन-जैसी लाइब्रेरी के संचालन के सिद्धांत की जांच की है - यह सब व्यवहार में आजमाने का समय है। मैं लुईस बोर्जेस द्वारा बनाई गई एक के करीब के रूप में विन्यास का उपयोग करूंगा। हम एक सरल वाक्यांश "habr.com" की खोज करेंगे:

 const libraryofbabel = require(`libraryofbabel`)({ lengthOfPage: 3200, alphabet: `abcdefghijklmnopqrstuvwxyz, .`, //, , ,  digs: `0123456789abcdefghijklmnopqrs`, // - 29-  wall: 4, shelf: 5, volume: 32, page: 410 //   }); //  console.log(libraryofbabel.search(`habr.com`));

भागो, परिणाम:

फिलहाल, यह हमें कुछ नहीं देता है। लेकिन आइए जानें कि इस पते के पीछे क्या छिपा है! कोड इस तरह होगा:

 const libraryofbabel = require(`libraryofbabel`)({ lengthOfPage: 3200, alphabet: `abcdefghijklmnopqrstuvwxyz, .`, //, , ,  digs: `0123456789abcdefghijklmnopqrs`, // - 29-  wall: 4, shelf: 5, volume: 32, page: 410 //   }); const text = `habr.com`; //  const adress = libraryofbabel.search(text); //    const clc = require(`cli-color`); //      console.log(libraryofbabel.getPage(adress).replace(text, clc.green(text)));

परिणाम:

हमने पाया कि हम अनंत (मैं शर्त) पृष्ठों की एक अनंत संख्या में क्या देख रहे थे!

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

 const libraryofbabel = require(`libraryofbabel`)({ lengthOfPage: 3200, alphabet: `abcdefghijklmnopqrstuvwxyz, .`, //, , ,  digs: `0123456789abcdefghijklmnopqrs`, // - 29-  wall: 4, shelf: 5, volume: 32, page: 410 //   }); const text = `habr.com`; //  const adress = libraryofbabel.search(text); //    const clc = require(`cli-color`); //      console.log(libraryofbabel.getPage(adress).replace(text, clc.green(text))); console.log(`\n : ${clc.green(libraryofbabel.getTitle(adress))}`);

पुस्तक का शीर्षक कुछ इस प्रकार है:

ईमानदारी से, यह बहुत आकर्षक नहीं लगेगा। फिर शीर्षक में हमारे वाक्यांश के साथ एक पुस्तक ढूंढते हैं:

 const libraryofbabel = require(`libraryofbabel`)({ lengthOfPage: 3200, alphabet: `abcdefghijklmnopqrstuvwxyz, .`, //, , ,  digs: `0123456789abcdefghijklmnopqrs`, // - 29-  wall: 4, shelf: 5, volume: 32, page: 410 //   }); const text = `habr.com`; //  const adress = libraryofbabel.searchTitle(text); //    const newAdress = `${adress}-${1}`; //    console.log(libraryofbabel.getPage(newAdress)); //     console.log(libraryofbabel.getTitle(newAdress)); //  ,        :)

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

 const libraryofbabel = require(`libraryofbabel`)({ lengthOfPage: 100, alphabet: `1010101010101010`, // 1  0,     digs: `0123456789abcdef`, // - 16-  wall: 4, shelf: 5, volume: 32, page: 410 //   }); const text = `10101100101010111001000000`; //  const adress = libraryofbabel.search(text); //    console.log(`\n${adress}\n`); //    const clc = require(`cli-color`); //      console.log(libraryofbabel.getPage(adress).replace(text, clc.green(text))); console.log(`\n : ${clc.green(libraryofbabel.getTitle(adress))}`);

आइए एक नज़र डालते हैं पूरा मैच देखने पर। ऐसा करने के लिए, पुराने उदाहरण पर वापस जाते हैं और कोड में Libraryofbabel.search को Libraryofbabel.searchExactly से प्रतिस्थापित करते हैं :

 const libraryofbabel = require(`libraryofbabel`)({ lengthOfPage: 3200, alphabet: `abcdefghijklmnopqrstuvwxyz, .`, //, , ,  digs: `0123456789abcdefghijklmnopqrs`, // - 29-  wall: 4, shelf: 5, volume: 32, page: 410 //   }); const text = `habr.com`; //  const adress = libraryofbabel.searchExactly(text); //    const clc = require(`cli-color`); //      console.log(libraryofbabel.getPage(adress).replace(text, clc.green(text))); console.log(`\n : ${clc.green(libraryofbabel.getTitle(adress))}`);

निष्कर्ष

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

आप पुस्तकालयों को लागू करने के लिए अन्य विकल्पों के साथ भी आ सकते हैं: किसी भी एन्क्रिप्शन एल्गोरिथ्म का उपयोग करें, जहां आपके व्यापक पुस्तकालय में सिफरटेक्स का पता होगा। डिक्रिप्शन - पृष्ठ सामग्री प्राप्त करना। या शायद कोशिश करेंआधार 64 , मी?

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

इस विचार का उपयोग "लाइब्रेरी" की एक किस्म बनाने के लिए किया जा सकता है। आप न केवल पात्रों, बल्कि पूरे शब्दों, या यहां तक कि ध्वनियों पर पुनरावृति कर सकते हैं! एक ऐसी जगह की कल्पना करें जहां आप मानवीय धारणा के लिए उपलब्ध किसी भी ध्वनि को सुन सकते हैं, या किसी प्रकार का गीत पा सकते हैं। भविष्य में मैं इसे लागू करने की कोशिश जरूर करूंगा।

रूसी में वेब संस्करण यहां उपलब्ध है , यह मेरे वर्चुअल सर्वर पर तैनात है। मैं बेबीलोन की लाइब्रेरी में जीवन के अर्थ के लिए सभी सुखद खोजों को नहीं जानता, या आप क्या बनाना चाहते हैं। अलविदा! :)

बेबीलोनियन पुस्तकालय का कार्यान्वयन