सोते समय विचार: भग्न मिश्रण एल्गोरिथ्म

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

एल्गोरिथ्म का सार इस प्रकार है: स्रोत डेटा का एक वेक्टर लिया जाता है और एन समान भागों में विभाजित किया जाता है (यदि वेक्टर एन द्वारा विभाजित नहीं है, तो "पूंछ" बस दाईं ओर छोड़ दी जाती है, हालांकि इसे भी छोड़ा जा सकता है)। ये एन भागों को किसी प्रकार के फेरबदल वेक्टर एम [एन] के अनुसार मिश्रित किया जाता है (जो तब प्राप्तकर्ता की कुंजी के रूप में प्रेषित किया जाता है, अगर यह एल्गोरिथ्म एन्क्रिप्शन के लिए उपयोग किया जाता है)। मिश्रण करने के बाद, मूल वेक्टर का प्रत्येक भाग समान रूप से एन बराबर भागों में विभाजित होता है, और प्रत्येक भाग के अंदर समान मिश्रण किया जाता है। तब यह बार-बार होता है जब तक यह संभव नहीं है।

यह उल्लेखनीय है कि यह एल्गोरिथ्म पुनरावृत्ति का उपयोग करके लागू करना आसान है, लेकिन इसे पुनरावृत्त रूप से भी लागू किया जा सकता है। इसके अलावा, मिक्सिंग एल्गोरिदम सममित है, अर्थात, मूल डेटा वेक्टर को प्राप्त करने के लिए, उसी वेक्टर m [N] के साथ इसे फिर से लागू करना आवश्यक है।

जब मैं इसके साथ आया था, मैंने तुरंत इसे भग्न कहा, क्योंकि मिश्रण मिश्रण के अंदर होता है (और "भग्न" शब्द शांत है)। और मैं तुरंत इसे Google में देखने के लिए चढ़ गया (सौभाग्य से, देश में मोबाइल इंटरनेट काम करता है)। लेकिन नहीं मिला! फिर मेरी आँखों में एक उत्साह की ज्वाला जगी - क्या मैं सचमुच कुछ नया और सरल लेकर आया हूँ? इस तरह के विचारों के बाद, मैं लंबे समय तक सो नहीं सका - लेकिन मैं मिश्रण एल्गोरिथ्म के बारे में इतना नहीं सोच रहा था कि मैं कैसे हेबर पर एक लेख लिखूंगा।
एक हफ्ते बाद, जब मैं पहले से ही घर पर था, मैंने अपने आलस पर काबू पा लिया और सी ++ कोड लिखा, जिसमें दिए गए नंबर एन का उपयोग करके, अपने एल्गोरिथ्म के साथ दिए गए स्ट्रिंग को मिलाया। सादगी के लिए, मैंने एक वेक्टर का उपयोग किया जो डेटा को पीछे की ओर फिर से व्यवस्थित करता है। लेकिन, निश्चित रूप से, एल्गोरिथ्म एक मनमाना मिश्रण वेक्टर के लिए डिज़ाइन किया गया है।

C ++ कोड

नोट: शफलस्ट्रीमिंग विधि को मुख्य रूप से कहा जाता है, मैं आपको सलाह देता हूं कि आप इससे कोड देखना शुरू करें।

class FractalShuffle { private: unsigned int* positions; unsigned int power; string data; /* *         : * 0, 1, 2, 3 -> 3, 2, 1, 0 */ void setReversePositions(unsigned int sizeOfVector) { unsigned int swap; for (unsigned int i = 0; i < sizeOfVector / 2; i++){ swap = positions[i]; positions[i] = positions[sizeOfVector - i - 1]; positions[sizeOfVector - i - 1] = swap; } } void recursiveShuffling(unsigned int startIndex, unsigned int atomSize) { string shuffledData; //    unsigned int size = atomSize - (atomSize % power); //   //(""   ) if (atomSize >= power){ //,     //atomSize -    ,    atomSize = size / power; //    for (unsigned int i = 0; i < power; i++){ shuffledData.append(data, startIndex + positions[i] * atomSize, atomSize); //         //(   positions),   - atomSize } for (unsigned int i = 0; i < size; i++){ data[startIndex + i] = shuffledData[i]; //       } shuffledData.clear(); // , //      //   for (unsigned int numberOfPart = 0; numberOfPart < power; numberOfPart++){ //     power  //        recursiveShuffling(startIndex + numberOfPart * atomSize, atomSize); } } } public: FractalShuffle(){}; ~FractalShuffle(){}; string shuffleString(string initialData, unsigned int _power) { if (_power <= 1){ return initialData; } if (initialData.length() < _power){ return initialData; } data = initialData; //    ,  //  .    . //  ,    . power = _power; positions = new unsigned int[power]; //   for (unsigned int i = 0; i < power; i++){ positions[i] = i; //    "0, 1, 2, 3..." } setReversePositions(power); //       recursiveShuffling(0, data.length()); //,  ""  delete[] positions; //       C++ return data; //   } }; 

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

"Hello_world!" N = 2 के लिए: dl! Owrol_eHl
"Hello_world!" N = 3 के लिए: dlr! W_ooleHl
"Hello_world!" N = 4 के लिए: ld! Worlo_Hel
"Hello_world!" N = 8 के लिए: ow_olleHrld!

बारीकियों

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

निष्कर्ष

निश्चित रूप से मैं इस तरह के एक एल्गोरिथ्म के साथ आने के लिए एक भ्रमपूर्ण अर्ध-सो में पहला नहीं था। लेकिन मुझे इसकी सादगी पसंद थी। मुझे टिप्पणियों में इसके लिंक प्राप्त करने में खुशी होगी!
मैं एक प्रश्न के साथ लेख को समाप्त करना चाहूंगा: बिस्तर पर जाने से पहले आप क्या सोचते हैं?