दिलचस्प पोस्ट
JSON को DataTable में कनवर्ट करें JQuery.browser का उपयोग कर सफ़ारी से क्रोम को भेद एप इंजन मॉड्यूल के बीच शेयरिंग संस्थाएं संकेत और संदर्भ के बीच वास्तविक अंतर क्या है? सेलेनियम में कैसे एक नया वेबपेज पर जाएं? जावा में दी गई सप्ताह संख्या का पहला दिन कैसे प्राप्त करें पैनल फ़ोकस नहीं हो रहा है एंड्रॉइड के लिए जेनी ट्यूटोरियल जावा में पहले गैर-शून्य मान कैसे प्राप्त करें? निमंत्रण या BeginInvoke को एक नियंत्रण पर नहीं बुलाया जा सकता जब तक विंडो हैंडल नहीं बनाया गया हो कस्टम ऐप के चलने में "ज्ञात फाइल प्रकार" खोलना – .NET सीएसवी डेटा को पार्स करने के लिए जावास्क्रिप्ट कोड सी प्रीप्रोसेसर में थोड़ी देर लूप लेखन क्या सामग्री_स्क्रिप्ट "क्रोम-एक्सटेंशन: // * / *" से मेल खाता है? एडीटी और एंड्रॉइड एसडीके उपकरणों को अद्यतन करने के बाद क्लास को त्रुटि मिली नहीं है

पूर्णांकों के अनुक्रम के लिए सर्वश्रेष्ठ संपीड़न एल्गोरिथ्म

मेरे पास एक पूर्णांक है जो पूर्णांक है जो ज्यादातर निरंतर है, जैसे 1-100, 110-160 आदि। सभी पूर्णांक सकारात्मक हैं I क्या इस सेक करने के लिए सबसे अच्छा एल्गोरिथ्म होगा?

मैंने डिफ्लेट एल्गोरिथम की कोशिश की लेकिन मुझे केवल 50% संपीड़न देता है ध्यान दें कि एल्गोरिदम हानिकारक नहीं हो सकता।

सभी नंबर अद्वितीय और उत्तरोत्तर बढ़ रहे हैं।

इसके अलावा यदि आप मुझे ऐसे एल्गोरिथम के जावा कार्यान्वयन के बारे में बता सकते हैं जो महान होगा।

Solutions Collecting From Web of "पूर्णांकों के अनुक्रम के लिए सर्वश्रेष्ठ संपीड़न एल्गोरिथ्म"

हमने हालिया शोध पत्र लिखा है जो इस समस्या के लिए सर्वोत्तम योजनाओं का सर्वेक्षण करता है। कृपया देखें:

डैनियल लिमरे और लियोनिद बोयत्सोव, वेक्टर्सिज़न के माध्यम से प्रति सेकंड पूर्णांक संख्या को डीकोडिंग, सॉफ्टवेयर: अभ्यास और अनुभव 45 (1), 2015. http://arxiv.org/abs/1209.2137

डैनियल लिमेर, नेथन कुर्ज़, लियोनिद बोयत्सोव, सीआईडी ​​संपीड़न और छंटनी वाले इंटिजर्स का चौराहे, सॉफ्टवेयर: अभ्यास और अनुभव (उपस्थित होने के लिए) http://arxiv.org/abs/1401.6399

इसमें एक व्यापक प्रायोगिक मूल्यांकन शामिल हैं

आप सी ++ 11 ऑनलाइन में सभी तकनीकों का एक पूरा कार्यान्वयन पा सकते हैं: https://github.com/lemire/FastPFor और https://github.com/lemire/SIMDCompressionAndIntersection

सी पुस्तकालय हैं: https://github.com/lemire/simdcomp और https://github.com/lemire/MaskedVByte

यदि आप जावा को पसंद करते हैं, तो कृपया https://github.com/lemire/JavaFastPFOR को देखें

सबसे पहले, प्रत्येक मूल्य और पिछले एक (पहले मान के लिए, पिछले एक शून्य था ग्रहण) के बीच अंतर लेने के द्वारा अपने मूल्यों की सूची preprocess। आपके मामले में यह चाहिए कि ज्यादातर लोगों का अनुक्रम, जो कि ज्यादातर संपीड़न एल्गोरिदम से अधिक आसानी से संकुचित हो सकते हैं।

ऐसा कैसे होता है कि पीएनजी प्रारूप अपने संपीड़न को सुधारने के लिए करता है (यह कई अंतर तरीकों में से एक होता है जिसके बाद एक ही संपीड़न एल्गोरिथ्म द्वारा इस्तेमाल किया गया है gzip)।

अच्छा, मैं चालाक तरीके से वोट कर रहा हूं आपको बस स्टोर करना है [इंट: स्टार्टनम्बर] [इंसट / बाइट / जो भी: संख्याओं की संख्या] इस मामले में, आप अपने एक्सप्लोरर सरणी को 4xInt मान में बदल देंगे। इसके बाद आप चाहते हैं कि आप संक्षिप्त कर सकते हैं 🙂

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

None 1.0 Deflate 0.50 Filtered 0.34 BZip2 0.11 Lzma 0.06 

क्या आकार संख्या हैं? अन्य उत्तरों के अतिरिक्त, आप आधार -128 संस्करण-लंबाई एन्कोडिंग पर विचार कर सकते हैं, जिससे आपको बड़ी संख्याओं को अनुमति देने के दौरान एकल संख्याओं को एक बाइट में संग्रहीत करने की सुविधा मिलती है। एमएसबी का अर्थ है "एक और बाइट है" – यह यहाँ वर्णित है।

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

इसलिए:

 1-100, 110-160 

"1 छोड़ें" (शून्य से शुरू होने पर लगता है क्योंकि यह चीज़ें आसान बनाता है), "100 लें", "9 छोड़ें", "51 ले"; प्रत्येक से 1 घटाएं, देकर (दशमलव के रूप में)

 0,99,8,50 

जो (हेक्स) के रूप में एन्कोड करता है:

 00 63 08 32 

अगर हम एक बड़ी संख्या को छोड़ना चाहते हैं – उदाहरण के लिए 300; हम 1 को 299 देकर घटाते हैं – लेकिन यह 7 बिट्स से अधिक हो जाता है; छोटे अंत से शुरू होने से, हम 7 बिट्स के ब्लॉक और एक एमएसबी को निरंतरता को इंगित करने के लिए एन्कोड करते हैं:

 299 = 100101100 = (in blocks of 7): 0000010 0101100 

तो बहुत कम अंत से शुरू होता है:

 1 0101100 (leading one since continuation) 0 0000010 (leading zero as no more) 

दे रही है:

 AC 02 

इसलिए हम बड़ी संख्या में आसानी से सांकेतिक शब्दों में बदल सकते हैं, लेकिन छोटी संख्या (जो कि स्पीप / ले जाने के लिए सामान्य है) कम स्थान लेती है।

आप "deflate" के माध्यम से इसे चलाने की कोशिश कर सकते हैं, लेकिन यह अधिक मदद नहीं कर सकता …


यदि आप अपने आप सभी गड़बड़ एन्कोडिंग क्रूड से निपटने के लिए नहीं चाहते हैं … यदि आप मूल्यों की पूर्णांक-सरणी (0, 99,8, 60) बना सकते हैं – आप प्रोटोकॉल बफ़र्स का प्रयोग एक दोहराए गए यूआईटी 32 / uint64 – और यह आपके लिए सभी काम करेगा; -पी

मैं "कर" जावा नहीं है, लेकिन यहां एक पूर्ण सी # कार्यान्वयन है (मेरे प्रोटॉबफ-नेट प्रोजेक्ट से कुछ एन्कोडिंग बिट्स को उधार लेना):

 using System; using System.Collections.Generic; using System.IO; using System.Linq; static class Program { static void Main() { var data = new List<int>(); data.AddRange(Enumerable.Range(1, 100)); data.AddRange(Enumerable.Range(110, 51)); int[] arr = data.ToArray(), arr2; using (MemoryStream ms = new MemoryStream()) { Encode(ms, arr); ShowRaw(ms.GetBuffer(), (int)ms.Length); ms.Position = 0; // rewind to read it... arr2 = Decode(ms); } } static void ShowRaw(byte[] buffer, int len) { for (int i = 0; i < len; i++) { Console.Write(buffer[i].ToString("X2")); } Console.WriteLine(); } static int[] Decode(Stream stream) { var list = new List<int>(); uint skip, take; int last = 0; while (TryDecodeUInt32(stream, out skip) && TryDecodeUInt32(stream, out take)) { last += (int)skip+1; for(uint i = 0 ; i <= take ; i++) { list.Add(last++); } } return list.ToArray(); } static int Encode(Stream stream, int[] data) { if (data.Length == 0) return 0; byte[] buffer = new byte[10]; int last = -1, len = 0; for (int i = 0; i < data.Length; ) { int gap = data[i] - 2 - last, size = 0; while (++i < data.Length && data[i] == data[i - 1] + 1) size++; last = data[i - 1]; len += EncodeUInt32((uint)gap, buffer, stream) + EncodeUInt32((uint)size, buffer, stream); } return len; } public static int EncodeUInt32(uint value, byte[] buffer, Stream stream) { int count = 0, index = 0; do { buffer[index++] = (byte)((value & 0x7F) | 0x80); value >>= 7; count++; } while (value != 0); buffer[index - 1] &= 0x7F; stream.Write(buffer, 0, count); return count; } public static bool TryDecodeUInt32(Stream source, out uint value) { int b = source.ReadByte(); if (b < 0) { value = 0; return false; } if ((b & 0x80) == 0) { // single-byte value = (uint)b; return true; } int shift = 7; value = (uint)(b & 0x7F); bool keepGoing; int i = 0; do { b = source.ReadByte(); if (b < 0) throw new EndOfStreamException(); i++; keepGoing = (b & 0x80) != 0; value |= ((uint)(b & 0x7F)) << shift; shift += 7; } while (keepGoing && i < 4); if (keepGoing && i == 4) { throw new OverflowException(); } return true; } } 

"1-100, 110-160" स्ट्रिंग को संक्षिप्त करें या कुछ बाइनरी प्रस्तुति में स्ट्रिंग को संचित करें और सरणी को पुनर्स्थापित करने के लिए इसे पार्स करें

अन्य समाधानों के अलावा:

आप "घने" क्षेत्रों को खोज सकते हैं और उन्हें स्टोर करने के लिए एक बिटमैप का उपयोग कर सकते हैं।

उदाहरण के लिए:

अगर आपके पास 1000-3000 के बीच 400 श्रेणियों में 1000 संख्याएं हैं, तो आप सीमा को दर्शाने के लिए एक संख्या और दो ints के अस्तित्व को दर्शाने के लिए एक बिट का उपयोग कर सकते हैं। इस श्रेणी के लिए कुल संग्रहण 2000 बिट्स + 2 इंच है, इसलिए आप उस जानकारी को 254bytes में संग्रहीत कर सकते हैं, जो बहुत ही भयानक है क्योंकि यहां तक ​​कि छोटे पूर्णांक भी दो बाइट्स लेते हैं, इसलिए इस उदाहरण के लिए आपको 7X बचत मिलती है।

घनीभूत क्षेत्रों में यह एल्गोरिथ्म बेहतर होगा, लेकिन कुछ बिंदु पर सिर्फ शुरू करने और खत्म करने का सस्ता सस्ता होगा।

मैं सीज़र बी और फर्नांडो मिगुएलेज़ द्वारा दिए गए उत्तरों को जोड़ता हूं।

सबसे पहले, प्रत्येक मूल्य और पिछले एक के बीच के मतभेदों को संग्रहित करें जैसा सीज़रबी ने बताया, यह आपको अधिकतर लोगों के अनुक्रम देगा।

उसके बाद, इस अनुक्रम पर रन लंबाई एन्कोडिंग संपीड़न एल्गोरिदम का उपयोग करें। दोहराया मूल्यों की बड़ी संख्या के कारण यह बहुत अच्छी तरह से संक्षिप्त होगा।

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

प्रारंभिक संख्या और श्रेणी के आकार को संचय करने के लिए, आपको संभवतया मूल विचार का उपयोग करना चाहिए, लगातार पूर्णांक के प्रत्येक श्रेणी के लिए (मैं इन श्रेणियों को कॉल करूंगा)। उदाहरण के लिए, यदि आपके पास 1000 पूर्णांकियों की सूची है, लेकिन केवल 10 अलग-अलग श्रेणियां हैं, तो आप इस डेटा का प्रतिनिधित्व करने के लिए सिर्फ 20 पूर्णांक (प्रत्येक संख्या के लिए 1 संख्या और 1 आकार) को स्टोर कर सकते हैं जो 98 की एक संपीड़न दर होगी %। सौभाग्य से, आप कुछ और ऑप्टिमाइज़ेशन कर सकते हैं जो आप कर सकते हैं जो उन मामलों में मदद करेगा जहां सीमाओं की संख्या बड़ा है।

  1. शुरुआती संख्या के मुकाबले शुरुआती संख्या की ऑफसेट को स्टोर करने के बजाय शुरुआती नंबर की तुलना करें यहां लाभ यह है कि आपके द्वारा संचयित संख्या में आमतौर पर कम बिट की आवश्यकता होती है (यह बाद के अनुकूलन सुझावों में उपयोगी हो सकता है)। इसके अतिरिक्त, यदि आप केवल शुरुआती संख्याओं को संग्रहीत करते हैं, तो ये नंबर सभी अद्वितीय होंगे, ऑफसेट भंडारण करते समय एक मौका मिलता है कि संख्याएं करीब या फिर दोहराती हैं जो आगे की संपीड़न के बाद भी लागू की जा सकती हैं।

  2. दोनों प्रकार के integers के लिए संभव बिट्स की न्यूनतम संख्या का उपयोग करें आप संख्याओं को पुनरावृत्त कर सकते हैं ताकि आरंभिक पूर्णांक के सबसे बड़े ऑफसेट और सबसे बड़ी सीमा के आकार को प्राप्त किया जा सके। आप तब एक डेटाटाइप का उपयोग कर सकते हैं जो कि सबसे अधिक कुशलता से इन पूर्णांकों को संग्रहीत करता है और संपीड़ित डेटा की शुरुआत में डेटाटाइप या बिट्स की संख्या निर्दिष्ट करता है। उदाहरण के लिए, यदि प्रारंभिक पूर्णांक का सबसे बड़ा ऑफसेट केवल 12,000 है, और सबसे बड़ी सीमा 9,000 लंबी है, तो आप इन सभी के लिए 2 बाइट हस्ताक्षरित पूर्णांक का उपयोग कर सकते हैं। तब आप संकुचित डेटा की शुरुआत में जोड़ी 2,2 को क्रैम कर सकते हैं, यह दिखाने के लिए कि 2 बाइट्स का उपयोग दोनों पूर्णांक के लिए किया जाता है बेशक आप इस जानकारी को थोड़ा बाइट का थोड़ा सा उपयोग करके एक बाइट में फिट कर सकते हैं। यदि आप बहुत अधिक भारी बिट हेरफेर करने में सहज हैं, तो आप प्रत्येक नंबर को 1, 2, 4 या 8 बाइट अभ्यावेदन के अनुरूप करने की बजाए न्यूनतम संभव मात्रा के बिट्स के रूप में स्टोर कर सकते हैं।

उन दो अनुकूलन के साथ कुछ उदाहरण देखें (प्रत्येक 4,000 बाइट्स हैं):

  1. 1,000 पूर्णांक, सबसे बड़ी ऑफसेट 500, 10 रेंज हैं
  2. 1,000 पूर्णांक, सबसे बड़ी ऑफसेट 100, 50 रेंज हैं
  3. 1,000 पूर्णांक, सबसे बड़ी ऑफसेट है 50, 100 रेंज

ऑप्टिमाइज़ेशन के बिना

  1. 20 पूर्णांक, 4 बाइट्स प्रत्येक = 80 बाइट्स संपीड़न = 98%
  2. 100 पूर्णांक, 4 बाइट्स प्रत्येक = 400 बाइट्स। संपीड़न = 90%
  3. 200 पूर्णांक, प्रत्येक 4 बाइट्स = 800 बाइट्स। संपीड़न = 80%

ऑप्टिमाइज़ेशन के साथ

  1. 1 बाइट हेडर + 20 नंबर, 1 बाइट प्रत्येक = 21 बाइट्स संपीड़न = 99.475%
  2. 1 बाइट हेडर + 100 नंबर, 1 बाइट प्रत्येक = 101 बाइट्स। संपीड़न = 97.475%
  3. 1 बाइट हेडर + 200 नंबर, 1 बाइट प्रत्येक = 201 बाइट्स। संपीड़न = 94.975%

आपका केस खोज इंजन में सूचकांक के संपीड़न के समान है। इस्तेमाल किया गया लोकप्रिय संपीड़न एल्गोरिथ्म PForDelta एल्गोरिदम और सरल 16 एल्गोरिथ्म है। आप अपनी संपीड़न जरूरतों के लिए किमिकज़े लाइब्रेरी का उपयोग कर सकते हैं

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

आप यहां और अन्य दोषरहित एल्गोरिदम पर एक नज़र डाल सकते हैं।

मुझे पता है कि यह एक पुराना संदेश धागा है, लेकिन मैं यहां पाया SKIP / TAKE विचार की अपनी निजी PHP परीक्षा शामिल कर रहा हूं। मैं अपना STEP (+) / SPAN (-) कह रहा हूं। शायद किसी को यह उपयोगी लग सकता है

नोट: मैंने डुप्लिकेट पूर्णांक के साथ ही नकारात्मक पूर्णांक को अनुमति देने की क्षमता को लागू किया है, हालांकि मूल प्रश्न में सकारात्मक, गैर-डुप्लिकेट पूर्णांक शामिल है। अगर आप एक बाइट या दो को दाम करने की कोशिश करना चाहते हैं

कोड:

  // $integers_array can contain any integers; no floating point, please. Duplicates okay. $integers_array = [118, 68, -9, 82, 67, -36, 15, 27, 26, 138, 45, 121, 72, 63, 73, -35, 68, 46, 37, -28, -12, 42, 101, 21, 35, 100, 44, 13, 125, 142, 36, 88, 113, -40, 40, -25, 116, -21, 123, -10, 43, 130, 7, 39, 69, 102, 24, 75, 64, 127, 109, 38, 41, -23, 21, -21, 101, 138, 51, 4, 93, -29, -13]; // Order from least to greatest... This routine does NOT save original order of integers. sort($integers_array, SORT_NUMERIC); // Start with the least value... NOTE: This removes the first value from the array. $start = $current = array_shift($integers_array); // This caps the end of the array, so we can easily get the last step or span value. array_push($integers_array, $start - 1); // Create the compressed array... $compressed_array = [$start]; foreach ($integers_array as $next_value) { // Range of $current to $next_value is our "skip" range. I call it a "step" instead. $step = $next_value - $current; if ($step == 1) { // Took a single step, wait to find the end of a series of seqential numbers. $current = $next_value; } else { // Range of $start to $current is our "take" range. I call it a "span" instead. $span = $current - $start; // If $span is positive, use "negative" to identify these as sequential numbers. if ($span > 0) array_push($compressed_array, -$span); // If $step is positive, move forward. If $step is zero, the number is duplicate. if ($step >= 0) array_push($compressed_array, $step); // In any case, we are resetting our start of potentialy sequential numbers. $start = $current = $next_value; } } // OPTIONAL: The following code attempts to compress things further in a variety of ways. // A quick check to see what pack size we can use. $largest_integer = max(max($compressed_array),-min($compressed_array)); if ($largest_integer < pow(2,7)) $pack_size = 'c'; elseif ($largest_integer < pow(2,15)) $pack_size = 's'; elseif ($largest_integer < pow(2,31)) $pack_size = 'l'; elseif ($largest_integer < pow(2,63)) $pack_size = 'q'; else die('Too freaking large, try something else!'); // NOTE: I did not implement the MSB feature mentioned by Marc Gravell. // I'm just pre-pending the $pack_size as the first byte, so I know how to unpack it. $packed_string = $pack_size; // Save compressed array to compressed string and binary packed string. $compressed_string = ''; foreach ($compressed_array as $value) { $compressed_string .= ($value < 0) ? $value : '+'.$value; $packed_string .= pack($pack_size, $value); } // We can possibly compress it more with gzip if there are lots of similar values. $gz_string = gzcompress($packed_string); // These were all just size tests I left in for you. $base64_string = base64_encode($packed_string); $gz64_string = base64_encode($gz_string); $compressed_string = trim($compressed_string,'+'); // Don't need leading '+'. echo "<hr>\nOriginal Array has " .count($integers_array) .' elements: {not showing, since I modified the original array directly}'; echo "<br>\nCompressed Array has " .count($compressed_array).' elements: ' .implode(', ',$compressed_array); echo "<br>\nCompressed String has " .strlen($compressed_string).' characters: ' .$compressed_string; echo "<br>\nPacked String has " .strlen($packed_string).' (some probably not printable) characters: ' .$packed_string; echo "<br>\nBase64 String has " .strlen($base64_string).' (all printable) characters: ' .$base64_string; echo "<br>\nGZipped String has " .strlen($gz_string).' (some probably not printable) characters: ' .$gz_string; echo "<br>\nBase64 of GZipped String has " .strlen($gz64_string).' (all printable) characters: ' .$gz64_string; // NOTICE: The following code reverses the process, starting form the $compressed_array. // The first value is always the starting value. $current_value = array_shift($compressed_array); $uncompressed_array = [$current_value]; foreach ($compressed_array as $val) { if ($val < -1) { // For ranges that span more than two values, we have to fill in the values. $range = range($current_value + 1, $current_value - $val - 1); $uncompressed_array = array_merge($uncompressed_array, $range); } // Add the step value to the $current_value $current_value += abs($val); // Add the newly-determined $current_value to our list. If $val==0, it is a repeat! array_push($uncompressed_array, $current_value); } // Display the uncompressed array. echo "<hr>Reconstituted Array has " .count($uncompressed_array).' elements: ' .implode(', ',$uncompressed_array). '<hr>'; 

उत्पादन:

 -------------------------------------------------------------------------------- Original Array has 63 elements: {not showing, since I modified the original array directly} Compressed Array has 53 elements: -40, 4, -1, 6, -1, 3, 2, 2, 0, 8, -1, 2, -1, 13, 3, 6, 2, 6, 0, 3, 2, -1, 8, -11, 5, 12, -1, 3, -1, 0, -1, 3, -1, 2, 7, 6, 5, 7, -1, 0, -1, 7, 4, 3, 2, 3, 2, 2, 2, 3, 8, 0, 4 Compressed String has 110 characters: -40+4-1+6-1+3+2+2+0+8-1+2-1+13+3+6+2+6+0+3+2-1+8-11+5+12-1+3-1+0-1+3-1+2+7+6+5+7-1+0-1+7+4+3+2+3+2+2+2+3+8+0+4 Packed String has 54 (some probably not printable) characters: cØÿÿÿÿ ÿõ ÿÿÿÿÿÿ Base64 String has 72 (all printable) characters: Y9gE/wb/AwICAAj/Av8NAwYCBgADAv8I9QUM/wP/AP8D/wIHBgUH/wD/BwQDAgMCAgIDCAAE GZipped String has 53 (some probably not printable) characters: xœ Ê» ÑÈί€)YšE¨MŠ“^qçºR¬m&Òõ‹%Ê&TFʉùÀ6ÿÁÁ Æ Base64 of GZipped String has 72 (all printable) characters: eJwNyrsNACAMA9HIzq+AKVmaRahNipNecee6UgSsBW0m0gj1iyXKJlRGjcqJ+cA2/8HBDcY= -------------------------------------------------------------------------------- Reconstituted Array has 63 elements: -40, -36, -35, -29, -28, -25, -23, -21, -21, -13, -12, -10, -9, 4, 7, 13, 15, 21, 21, 24, 26, 27, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 51, 63, 64, 67, 68, 68, 69, 72, 73, 75, 82, 88, 93, 100, 101, 101, 102, 109, 113, 116, 118, 121, 123, 125, 127, 130, 138, 138, 142 -------------------------------------------------------------------------------- + 0-1 + 3-1 + 2 + 7 + 6 + 5 + 7-1 + 0-1 + 7 + 4 + 3 + 2 + 3 + 2 -------------------------------------------------------------------------------- Original Array has 63 elements: {not showing, since I modified the original array directly} Compressed Array has 53 elements: -40, 4, -1, 6, -1, 3, 2, 2, 0, 8, -1, 2, -1, 13, 3, 6, 2, 6, 0, 3, 2, -1, 8, -11, 5, 12, -1, 3, -1, 0, -1, 3, -1, 2, 7, 6, 5, 7, -1, 0, -1, 7, 4, 3, 2, 3, 2, 2, 2, 3, 8, 0, 4 Compressed String has 110 characters: -40+4-1+6-1+3+2+2+0+8-1+2-1+13+3+6+2+6+0+3+2-1+8-11+5+12-1+3-1+0-1+3-1+2+7+6+5+7-1+0-1+7+4+3+2+3+2+2+2+3+8+0+4 Packed String has 54 (some probably not printable) characters: cØÿÿÿÿ ÿõ ÿÿÿÿÿÿ Base64 String has 72 (all printable) characters: Y9gE/wb/AwICAAj/Av8NAwYCBgADAv8I9QUM/wP/AP8D/wIHBgUH/wD/BwQDAgMCAgIDCAAE GZipped String has 53 (some probably not printable) characters: xœ Ê» ÑÈί€)YšE¨MŠ“^qçºR¬m&Òõ‹%Ê&TFʉùÀ6ÿÁÁ Æ Base64 of GZipped String has 72 (all printable) characters: eJwNyrsNACAMA9HIzq+AKVmaRahNipNecee6UgSsBW0m0gj1iyXKJlRGjcqJ+cA2/8HBDcY= -------------------------------------------------------------------------------- Reconstituted Array has 63 elements: -40, -36, -35, -29, -28, -25, -23, -21, -21, -13, -12, -10, -9, 4, 7, 13, 15, 21, 21, 24, 26, 27, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 51, 63, 64, 67, 68, 68, 69, 72, 73, 75, 82, 88, 93, 100, 101, 101, 102, 109, 113, 116, 118, 121, 123, 125, 127, 130, 138, 138, 142 -------------------------------------------------------------------------------- 

TurboPFor: सबसे तेज पूर्णांक संपीड़न

  • जावा क्रिटिकल मूल निवासी / जेएनआई इंटरफ़ेस सहित सी / सी ++ के लिए
  • SIMD पूर्णांक संपीड़न त्वरित
  • स्केलर + इंटिग्रेटेड (SIMD) डिफरेंशियल / सिकुल्ड / असम्बद्ध पूर्णांक सूचियों के लिए एन्कोडिंग / डिकोडिंग Zigzag
  • पूर्ण सीमा 8/16/32/64 बिट्स इंटरर्जर्स सूचियां
  • सीधी पहुँच
  • बेंचमार्क ऐप

मैं अपनी संपीड़न को इसके बारे में 11 से ज्यादा बेहतर नहीं कर सका। मैंने अपने परीक्षण डेटा को अजगर दुभाषिया के माध्यम से जनरेट किया है और यह 1-100 से 110 और 110 के पूर्णांक की एक नई पंक्ति सीमांकित सूची है मैं डेटा के संकुचित प्रतिनिधित्व के रूप में वास्तविक कार्यक्रम का उपयोग करता हूं। मेरी संकुचित फाइल इस प्रकार है:

 main=mapM_ print [x|x<-[1..160],x`notElem`[101..109]] 

यह सिर्फ एक हस्केल स्क्रिप्ट है जो फ़ाइल को आपके द्वारा चलाया जा सकता है:

 $ runhaskell generator.hs >> data 

जीएचएस फ़ाइल का आकार 54 बाइट्स है, और अजगर उत्पन्न डेटा 496 बाइट्स है। यह 0.108870 9 6774193548 को संपीड़न अनुपात के रूप में देता है। मुझे लगता है कि अधिक समय से कोई प्रोग्राम को छोटा कर सकता है, या आप संपीड़ित फ़ाइल (यानी हैस्केल फ़ाइल) को संक्षिप्त कर सकते हैं

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

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