一致的头顶拜特填料(棒)

Question

我很惊讶这个还没被发布过！

一致开销字节填充 (COBS)算法用于分隔字节流。

我们选择一个帧标记(我们将使用0x00)，无论0x00发生在流中，它都被替换为字节数，直到下一个0x00出现(我们将称之为里程碑)。这将值的范围从0.255减少到1.255，从而使0x00能够明确地分隔流中的帧。

在一个里程碑，如果下一个255 B不包含0x00，这超过了最大里程碑长度-算法必须‘停止’在255 B，并放置另一个里程碑。这是“一致的开销”。

第一个字节将是第一个里程碑，最后一个里程碑将是直到帧标记的字节数。

维基百科的一些例子(最好阅读文章的颜色)：

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。

Notes

• 最坏的情况是返回长度是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.

Answer 1

JavaScript (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

Java (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

Python 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]

在网上试试！