令我惊讶的是，这还没有发布！

在一致的开销字节填充（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.

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))

在线尝试！

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;}

在线尝试！

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]

在线尝试！

果冻，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

灵药，109字节

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

在线尝试！

J，103个字符

请注意，最后一个测试用例的结果不同于Wiki和其他语言。这是由于该指针指向边界处的第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
 )

在线试用