पायथन का उपयोग करके एक पुन: प्रयोज्य सरल रूप में एक बहुत लंबे बायनेरिज़ स्ट्रिंग को एन्कोड करने का सबसे अच्छा तरीका है?

Jan 13 2021

-------------------------- नया जोड़ो---------------------- -------

मुझे यहाँ और जानकारी भरने दें:

वास्तविक स्थिति यह है कि मेरे पास पर्यावरण-ए में यह लंबी ताकत है, और मुझे इसे पर्यावरण-बी में कॉपी और पेस्ट करने की आवश्यकता है;

UNFORTUNATELY, envir-A और envir-B जुड़े हुए नहीं हैं (कोई पारस्परिक पहुँच नहीं है), इसलिए मैं इसका प्रतिनिधित्व करने के लिए सांकेतिक शब्दों में बदलना / डिकोड करने के तरीके के बारे में सोच रहा हूं, अन्यथा अधिक फ़ाइलों के लिए मुझे हाथ से स्ट्रिंग का इनपुट करना होगा --- -जो धीमा है और प्रजनन योग्य नहीं है।

किसी भी सुझाव या गैजेट की सिफारिश? बहुत धन्यवाद!

मैं कई अंकों की तरह एक साधारण रूप से एक सुपर लंबी द्विपदीय एनकोड करने के लिए एक अजीब समस्या का सामना कर रहा हूं।

कहते हैं, 1,000 और 100,000 या उससे अधिक अंकों की लंबाई में केवल 1 और 0, उदाहरण के लिए "110 ... 011" होता है, और मैं इस STRING को ऐसी चीज़ में संलग्न करना चाहूंगा, जिसमें कम अंक / वर्ण हों। फिर मुझे इसे मूल STRING में वापस करना होगा।

वर्तमान में मैं इस स्ट्रींग को 'कंप्रेस' करने के लिए पाइथन में हेक्स / इंट मेथड का उपयोग करके कोशिश कर रहा हूं और इसे 'डीकंप्रेस' करके मूल रूप में वापस ला सकता हूं।

एक उदाहरण होगा:

1.पुट स्ट्रिंग: '110011110110011'

'' ''

def Bi_to_Hex_Int(input_str, method ):

#2to16 
if method=='hex':
    string= str(input_str)
    input_two= string
    result=    hex(int(input_two,2))
    
#2to10 
if method=='int':
    string= str(input_str)
    input_two= string
    result=     int(input_two,2) 


print("input_bi length",len(str(input_two)), "\n output hex length",len(str(result)),'\n method: {}'.format(method) )
return result


res_16 =Bi_to_Hex_Int(gene , 'hex')
=='0x67b3'

res_10 =Bi_to_Hex_Int(gene , 'int')
== 26547

'' ''

तो मैं इसे वापस उल्टा कर सकता हूं:

'' ''

def HexInt_to_bi(input_str , method):


if method =='hex':

    back_two =  bin(int(input_str,16))

    back_two =  back_two[2:]
    
     
if method =='int':

    back_two =  bin( int(input_str ))

    back_two =  back_two[2:]
    
    
print("input_hex length",len(str(input_str)), "\n output bi length",len(str(back_two)) )
return back_two


hexback_two = HexInt_to_bi(res_16, 'hex')
intback_two = HexInt_to_bi(res_10 , 'int')

'' ''

लेकिन, यह एक समस्या है, मैंने स्ट्रिंग के लगभग 500 अंकों की कोशिश की: 101010 ... 0001 (500d), सबसे अच्छा 'संकुचित' परिणाम हेक्स द्वारा लगभग 127 अंक है;

तो क्या कम अंकों के लिए 'कंप्रेस' स्ट्रिंग को आगे बढ़ाने का एक बेहतर तरीका है?

** कहते हैं कि स्ट्रिंग के 5,000 अंकों में 1s और 0s होते हैं, 50/100 को कुछ अंकों / वर्णों (यहां तक कि कम) से संकुचित करते हैं ??

जवाब

1 Som-1 Jan 13 2021 at 19:19

यदि आप इसे सरल चाहते हैं, तो कहें कि 1 हेक्स वर्ण 4 बाइनरी वर्णों को संकुचित करता है (2 ^ 4 = 16)। आप चाहते हैं कि संपीड़न अनुपात लगभग 100/50 गुना हो। 50 बार आपको 50 द्विआधारी वर्णों को 1 वर्ण में संपीड़ित करने की आवश्यकता है, इसका मतलब है कि आपको किसी भी संयोजन को एन्कोड करने के लिए 2 ^ 50 विभिन्न वर्णों की आवश्यकता है। काफी जो है।

यदि आप कम अनुपात स्वीकार करते हैं, तो आप यहाँ वर्णित की तरह बेस 64 का प्रयास कर सकते हैं । इसका संपीड़ित अनुपात 6 से 1 है।

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

संभवत: एक आर्किवेटर के साथ अपनी स्ट्रिंग को संपीड़ित करना आसान है , फिर परिणाम का एक बेस 64 प्रतिनिधित्व लौटाएं।

यदि कार्य अनुमति देता है, तो आप पूरे स्ट्रिंग्स को कहीं स्टोर कर सकते हैं और उन्हें छोटे अनूठे नाम दे सकते हैं, इसलिए संपीड़न और विघटन के बजाय आपको नामों द्वारा स्ट्रिंग्स को स्टोर और पुनः प्राप्त करना होगा।

1 MarkRansom Jan 14 2021 at 01:52

यह संभवतः आप प्राप्त कर सकते हैं सबसे कम स्ट्रिंग का उत्पादन नहीं करता है, लेकिन पायथन में निर्मित सुविधाओं का उपयोग करके यह बहुत आसान है। वर्णों को एक द्विआधारी प्रारूप में बदलने की आवश्यकता नहीं है, zlibसंपीड़न केवल 2 अलग-अलग वर्णों के साथ एक इनपुट को कुछ इष्टतम में बदल देगा।

एन्कोडिंग:

import zlib
import base64
result = base64.b64encode(zlib.compress(input_str.encode()))

1 TThoEinthausend Jan 14 2021 at 04:08

अगर की गिनती 0और 1महत्वपूर्ण अलग से आप उपयोग कर सकते है गणनासूचक कम से कम प्रतिनिधित्व प्राप्त करने के लिए कोडिंग

MarkAdler Jan 14 2021 at 01:32

स्ट्रिंग होते हैं तो केवल की 0और 1अंक है, तो आप एक बाइट में आठ अंक पैक कर सकते हैं। आपको यह भी ध्यान रखने की आवश्यकता होगी कि आठ के अंतिम गुणकों में कितने अंक हैं, क्योंकि अंतिम बाइट आठ अंकों से कम का प्रतिनिधित्व कर सकता है।