Estou surpreso que isso não tenha sido publicado antes!

O algoritmo COBS ( Overhead Byte Overhead Consistente ) é usado para delimitar fluxos de bytes.

Escolhemos um marcador de quadro (usaremos 0x00) e, sempre que 0x00 ocorre no fluxo, ele é substituído pelo número de bytes até o próximo 0x00 (chamaremos isso de marco). Isso reduz o intervalo de valores de 0..255 a 1..255, permitindo que 0x00 delimite inequivocamente os quadros no fluxo.
Em um marco, se o próximo 255B não contiver 0x00, isso excede o comprimento máximo do marco - o algoritmo deve 'parar' em 255B e colocar outro marco. Essa é a "sobrecarga consistente".
O primeiro byte será o primeiro marco, o marco final será o número de bytes até o marcador do quadro.

Alguns exemplos da Wikipedia (melhor ler o artigo em que são coloridos):

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

Desafio: implementar isso no programa mais curto.

• A entrada é um fluxo / matriz de bytes não codificados, a saída é um fluxo / matriz de bytes codificados
• Use qualquer tipo de entrada / saída padrão binária
• O marcador de quadro final não é necessário
• O programa pode retornar uma matriz de grandes dimensões
• Um fluxo que termina com 254 bytes diferentes de zero não requer o 0x00 à direita

Notas

• O pior retorno do comprimento é numBytes + (numBytes / 254) + 1

Exemplo

Temos a matriz de bytes

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

Para cada um 0x00, precisamos declarar (em um marco) onde o próximo 0x00teria sido.

[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 bytes

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

Experimente online!

Java (JDK) , 143 bytes

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

Experimente online!

Python 2 , 125 bytes

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]

Experimente online!

Gelatina , 27 bytes

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

Experimente online!

Um link monádico que recebe uma matriz de bytes não codificados como entrada e retorna a matriz de bytes codificados. De acordo com as regras, o marcador de quadro final é omitido.

Explicação

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

Elixir , 109 bytes

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

Experimente online!

J , 103 caracteres

Observe que o resultado do último caso de teste é diferente do wiki e de outros idiomas. Isso ocorre devido a esse ponteiro para 254-th byte zero no limite. As coisas ficam muito mais fáceis, se isso não for tratado como um caso especial.

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

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

Experimente Online