लगातार उपरि बाइट भराई (COBS)

Question

मुझे आश्चर्य है कि यह पहले पोस्ट नहीं किया गया है!

लगातार ओवरहेड बाइट स्टफ़िंग (cobs) एल्गोरिथ्म परिसीमित बाइट धाराओं किया जाता है।

हम एक फ्रेम मार्कर चुनते हैं (हम 0x00 का उपयोग करेंगे) और जहां भी 0x00 स्ट्रीम में होता है उसे बाइट्स की संख्या के साथ बदल दिया जाता है जब तक कि अगला 0x00 होता है (हम इसे मील का पत्थर कहेंगे)। यह मानों की सीमा को 0..255 से घटाकर 1..255 तक कम कर देता है, जिससे 0x00 को स्ट्रीम में स्पष्ट रूप से परिसीमित फ्रेम में सक्षम किया जाता है।
एक मील के पत्थर पर, अगर अगले 255B में 0x00 शामिल नहीं है, तो यह अधिकतम मील का पत्थर की लंबाई से अधिक है - एल्गोरिथ्म को 255B पर 'स्टाल' करना होगा और दूसरा मील का पत्थर रखना होगा। यह 'सुसंगत ओवरहेड' है।
पहला बाइट पहला मील का पत्थर होगा, अंतिम मील का पत्थर फ्रेम मार्कर तक बाइट्स की संख्या होगी।

विकिपीडिया से कुछ उदाहरण (लेख को पढ़ने के लिए सबसे अच्छा है जहाँ वे रंगीन हैं):

0x00 as frame marker

Unencoded data (hex)    Encoded with COBS (hex)
00                      01 01 00
00 00                   01 01 01 00
11 22 00 33             03 11 22 02 33 00
11 22 33 44             05 11 22 33 44 00
11 00 00 00             02 11 01 01 01 00
01 02 03 ... FD FE      FF 01 02 03 ... FD FE 00
00 01 02 ... FC FD FE   01 FF 01 02 ... FC FD FE 00
01 02 03 ... FD FE FF   FF 01 02 03 ... FD FE 02 FF 00
02 03 04 ... FE FF 00   FF 02 03 04 ... FE FF 01 01 00
03 04 05 ... FF 00 01   FE 03 04 05 ... FF 02 01 00

चुनौती: इसे कम से कम कार्यक्रम में लागू करना।

• इनपुट एक अनएन्कोडेड बाइट स्ट्रीम / सरणी है, आउटपुट एक एनकोडेड बाइट स्ट्रीम / एरे है
• किसी भी प्रकार के बाइनरी मानक इनपुट / आउटपुट का उपयोग करें
• अंतिम फ्रेम मार्कर आवश्यक नहीं है
• कार्यक्रम एक ओवरसाइज़्ड सरणी लौटा सकता है
• 254 गैर-शून्य बाइट्स के साथ समाप्त होने वाली धारा को अनुगामी 0x00 की आवश्यकता नहीं होती है

टिप्पणियाँ

• सबसे खराब स्थिति वापसी की लंबाई है numBytes + (numBytes / 254) + 1

उदाहरण

हमारे पास बाइट सरणी है

[0] 0x01
[1] 0x02
[2] 0x00
[3] 0x03
[4] 0x04
[5] 0x05
[6] 0x00
[7] 0x06

प्रत्येक के लिए 0x00हमें (एक मील के पत्थर में) स्टेट की जरूरत है, जहां अगला 0x00होगा।

[0] 0x03   #Milestone. Refers to the original [2] - "The next 0x00 is in 3B"
[1] 0x01   #Original [0]
[2] 0x02   #Original [1]
[3] 0x04   #Milestone. Refers to the original [6] - "The next 0x00 is in 4B"
[4] 0x03   #
[5] 0x04   #
[6] 0x05   # Originals [3..5]
[7] 0x02   #Milestone. Refers to the end frame marker
[8] 0x06   #Original [7]
[9] 0x00   #Optional. End frame marker.

Comments

आपको संभवतः इसे कल्पना में शामिल करना चाहिए: एक विशेष अपवाद के रूप में, यदि कोई पैकेट 254 गैर-शून्य बाइट्स के समूह के साथ समाप्त होता है, तो अनुगामी शून्य बाइट जोड़ना आवश्यक नहीं है। यह कुछ स्थितियों में एक बाइट बचाता है। (विकिपीडिया के हवाले से)

— अरनौल्ड 12

@LuisMendo सहमत। अब जब मैं सभी परीक्षण मामलों से गुजर चुका हूं, तो मैं पुष्टि कर सकता हूं कि यह वर्तमान में थोड़ा सा कम है।

— अरनुलद

@Arnauld, मैंने कहा है कि अंतिम फ्रेम निर्माता वैसे भी आवश्यक नहीं है :)

— पैट्रिक

उदाहरण में, पहला आउटपुट बाइट 0x03 होना चाहिए, न कि 0x02, जब तक मैं गलत नहीं हूँ ...

— Olivier Grégoire

@ अरनल्ड 254 गैर-शून्य बाइट्स के साथ समाप्त होने के विशेष मामले के बारे में: सहमत हैं, और यह अंतिम फ्रेम मार्कर के लिए एक अलग मुद्दा है। यही कारण है कि छठे उदाहरण में अनुगामी नहीं है, 01लेकिन दो हैं01 नौवें एक में एस (जहां एक शून्य के बाद 254 गैर-शून्य बाइट्स हैं)।

— निक केनेडी

Answer 1

जावास्क्रिप्ट (Node.js) , 114 बाइट्स

a=>(g=([v,...a])=>1/v?[v||a.indexOf(0)+1,...g(a)]:[])([0,...a,0].flatMap((v,j)=>1/a[j]&&(i=v&&i+1)>253?[v,i=0]:v))

इसे ऑनलाइन आज़माएं!

Answer 2

जावा (JDK) , 143 बाइट्स

a->{int l=a.length,r[]=new int[l+2],i=0,j=1,x=1,z=0;for(;i<l;){if(a[i]>0)r[j++]=a[i];if(a[i++]<1||++x>254){r[z]=x;z=j++;x=1;}}r[z]=x;return r;}

इसे ऑनलाइन आज़माएं!

Answer 3

पायथन 2 , 125 बाइट्स

def f(a):
 r=[[]]
 for v in a:r+=[[]]*((len(r[-1])>253)+(v<1));r[-1]+=[v]*(v>0)
 return sum([[len(x)+1]+x for x in r],[])+[0]

इसे ऑनलाइन आज़माएं!

Answer 4

जेली , 27 बाइट्स

Oµ=0ks€254Ẏḟ€0L‘;Ɗ€F;Ṫ¬x`ƊỌ

इसे ऑनलाइन आज़माएं!

एक मोनैडिक लिंक जो इनपुट के रूप में एक अनएन्कोडेड बाइट सरणी लेता है और एन्कोडेड बाइट ऐरे को वापस करता है। नियमों के अनुसार, अंतिम फ्रेम मार्कर छोड़ा जाता है।

व्याख्या

Oµ                          | Convert to integer and start a new monadic chain
  =0k                       | Split after zeros
     s€254                  | Split each list into length 254 lists
          Ẏ                 | Tighten (reduce list depth by 1)
           ḟ€0              | Filter zeros out from each list
              L‘;Ɗ€         | Prepend the list length plus one to each list
                   F        | Flatten
                    ;Ṫ¬x`Ɗ  | Append an additional 1 if the original list ended with zero
                          Ọ | Convert back to bytes

Answer 5

अमृत , 109 बाइट्स

&Regex.replace~r/(^|(?<=([^\0]{254}))(?!$)|\0)((?2)|[^\0]*?(?=\0|$))/,&1,fn _,_,_,x-><<1+byte_size x>><>x end

इसे ऑनलाइन आज़माएं!

Answer 6

जे , 103 चार्ट

ध्यान दें अंतिम परीक्षण मामले का परिणाम विकि और अन्य भाषाओं से अलग है। यह इस संकेतक के कारण सीमा पर 254-वें शून्य बाइट के लिए है। अगर यह एक विशेष मामले के रूप में नहीं माना जाता है, तो चीजें बहुत आसान हो जाती हैं।

f =: 3 : 0
  k =. I. (y,0)=0
  s =. - 2 (-/) \ k
  (>: y i. 0), s (}:k) } y
 )

 f2 =: 3 : 0
   f each _254 <\ y
 )

यह ऑनलाइन की कोशिश करो

Comments

अंतिम पंक्ति के अंत में अनुगामी स्थान को हटाकर आप इसे 1 बाइट से नीचे ले जा सकते हैं ।

— ouflak