Tarefa

Dada uma string UTF-8 (por qualquer meio), responda (por qualquer meio) uma lista equivalente em que cada elemento é o número de bytes usados ​​para codificar o caractere de entrada correspondente.

Exemplos

! → 1

Ciao → 1 1 1 1

tʃaʊ → 1 2 1 2

Adám → 1 1 2 1

ĉaŭ→ 2 1 2(caracteres únicos)

ĉaŭ→ 1 2 1 1 2(usa combinações de sobreposições)

チャオ → 3 3 3

(entrada vazia) → (saída vazia)

!±≡𩸽 → 1 2 3 4

(um byte nulo) → 1

Bytes nulos

Se a única maneira de continuar lendo a entrada além de bytes nulos é conhecendo a contagem total de bytes, você poderá obtê-la por qualquer meio (inclusive a entrada do usuário).

Se seu idioma não puder manipular bytes nulos, você poderá assumir que a entrada não contém nulos.

Pitão, 9 7 bytes

Obrigado a @Maltysen por salvar 2 bytes!

mlc.Bd8

Suíte de teste

Converte todos os caracteres da entrada na sua representação binária e, em seguida, divide-os em pedaços de comprimento 8. O número desses pedaços é a quantidade de bytes necessários para codificar esse caractere.

Python 3, 42 36 bytes

lambda x:[len(i.encode())for i in x]

C, 68 65 bytes

b;main(c){for(;~c;b=c/64^2?b?putchar(b+48)/48:1:b+1)c=getchar();}

Graças a @FryAmTheEggman por jogar fora 3 bytes!

Teste em Ideone .

APL, 15 caracteres

≢¨'UTF-8'∘⎕ucs¨

Em inglês: converta cada caractere em UTF-8 (ou seja: representação do vetor de bytes) e obtenha sua contagem.

GolfScript, 16 bytes

{64/2=}%1,/{,)}*

Experimente online!

fundo

GolfScript não tem idéia do que é Unicode; todas as strings (entrada, saída, interna) são compostas de bytes. Embora isso possa ser muito chato, é perfeito para esse desafio.

UTF-8 codifica caracteres ASCII e não ASCII de maneira diferente:

• Todos os pontos de código abaixo de 128 são codificados como 0xxxxxxx .

• Todos os outros pontos de código são codificados como 11xxxxxx 10xxxxxx ... 10xxxxxx .

Isso significa que a codificação de cada caractere Unicode contém um único 0xxxxxxxbyte ou um único11xxxxxx byte e 1 a 5 10xxxxxxbytes.

Ao dividir todos os bytes da entrada por 64 , transformamos 0xxxxxxxem 0 ou 1 , 11xxxxxxem 3 e 10xxxxxxem 2 .

Se compararmos o quociente com 2 - pressionar 1 por 2 ; e 0 para 0 , 1 e 3 - cada caractere será transformado em 0 , seguido de 1 a 5 1 's.

Tudo o que resta é dividir a sequência resultante nas ocorrências de 0 , contar o número de1's between those zeroes and add one to the amount.

Como funciona

{     }%          Map the following over all bytes in the input.
 64/                Divide the byte by 64.
    2=              Compare the quotient with 2, pushing 1 or 0.
        1,        Push range(1), i.e., [0].
          /       Split the array of Booleans around zeroes.
           {  }*  Fold; for each run of ones but the first:
            ,       Push its length.
             )      Increment.

PowerShell v4, 58 bytes

[char[]]$args[0]|%{[Text.Encoding]::UTF8.GetByteCount($_)}

NB

OK, isso deve funcionar e funciona em quase todos os casos de teste, exceto os 𩸽que, de alguma forma, são contados como 3,3na minha máquina. Esse personagem até mostra como7 bytes on my computer. I suspect this is due to some sort of bug in the Windows or .NET version that I'm running locally, as @Mego doesn't have that issue. (Edit: @cat points out this is due to BOM. Thanks for solving that mystery, @cat!)

No entanto, isso ainda não explica todo o problema. Acho que sei de onde vêm alguns dos problemas. Dentro do .NET, todas as seqüências são compostas de unidades de código UTF-16 (que é o tipo System.Char). Com a conversão de texto muito flexível que o PowerShell usa, há muitas projeções e conversões implícitas entre os tipos em segundo plano. Provavelmente, esse é um fator que contribui para o comportamento que estamos vendo - por exemplo, [system.text.encoding]::utf8.getchars([System.Text.UTF8Encoding]::UTF8.GetBytes('𩸽'))retorna dois não imprimíveis, em vez de um único caractere.

Explicação

Código muito simples. Pega a entrada $args[0]e a lança explicitamente como um array de caracteres, para que possamos percorrer cada componente da string |%{...}. A cada iteração, usamos a chamada .NET [System.Text.Encoding]::UTF8.GetByteCount()(o System.implícito) para obter a contagem de bytes do caractere atual $_. Isso é colocado no pipeline para saída posterior. Uma vez que é uma coleção de[int] s retornada, a conversão para uma matriz está implícita.

Execuções de teste

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 'tʃaʊ'
1
2
1
2

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 'Adám'
1
1
2
1

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 'ĉaŭ'
2
1
2

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 'ĉaŭ'
1
2
1
1
2

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 'チャオ'
3
3
3

PS C:\Tools\Scripts\golfing> .\bytes-per-character.ps1 '!±≡𩸽'
1
2
3
3
3

Editado para adicionar Isso explica adequadamente o requisito de bytes nulos que foi adicionado ao desafio depois que eu postei originalmente, desde que você extraia os dados de um arquivo de texto e os canalize da seguinte maneira:

PS C:\Tools\Scripts\golfing> gc .\z.txt -Encoding UTF8|%{.\bytes-per-character.ps1 $_}
2
1
1
1

JavaScript (ES6), 54 45 43 bytes

s=>[...s].map(c=>encodeURI(c).length/3-8&7)

Editar: salvou 2 bytes com a ajuda de @ l4m2.

Ruby, 33 bytes

Mal chega ao Python, sim! Experimente online.

->s{s.chars.map{|c|c.bytes.size}}

Perl 6 ,  77 69  63 bytes

put +$0 if $_».base(2).fmt("%8d")~~/^(1)**2..*|^(" ")/ while $_=$*IN.read: 1

put +$0 if $_».fmt("%8b")~~/^(1)**2..*|^(" ")/ while $_=$*IN.read: 1

put 1+$0 if $_».fmt("%8b")~~/^1(1)+|^" "/while $_=$*IN.read: 1

put 1+$0 if $_».fmt("%0.8b")~~/^1(1)+|^0/while $_=$*IN.read: 1

Como o Perl 6 usa cadeias NFG, eu tenho que extrair os bytes diretamente, o que evita o recurso.
(NFG é como NFC, exceto que também cria pontos de código compostos sintéticos)

A saída é separada por novas linhas.

Teste:

for text in '!' 'Ciao' 'tʃaʊ' 'Adám' 'ĉaŭ' 'ĉaŭ' 'チャオ' '' '!±≡𩸽' '𩸽\0𩸽';
do
  echo -en $text |
  perl6 -e 'put 1+$0 if $_».fmt("%8b")~~/^1(1)+|^" "/while $_=$*IN.read: 1' |

  # combine all of the lines into a single one for display purposes
  env text=$text perl6 -e 'put qq["%*ENV<text>"], "\t\t", lines.gist'
done

"!"     (1)
"tʃaʊ"      (1 2 1 2)
"Adám"      (1 1 2 1)
"ĉaŭ"       (2 1 2)
"ĉaŭ"     (1 2 1 1 2)
"チャオ"       (3 3 3)
""      ()
"!±≡𩸽"     (1 2 3 4)
"𩸽\0𩸽"        (4 1 4)

Explicação:

# turns the list in ｢$0｣ into a count, and adds one
# ｢put｣ prints that with a trailing newline
put 1+$0 

   # if the following is true
   if

       # format the input byte to base 2 and pad it out to 8 characters
       $_».fmt("%8b")

       ~~ # smart match against

       # check to see if it starts with more than one 1s, or a space
       # ( also sets ｢$0｣ to a list that is 1 shorter
       # than the number of bytes in this codepoint )
       / ^1 (1)+ | ^" " /

           # for every byte in STDIN
           while
               $_ = $*IN.read: 1

Isso funciona porque o primeiro byte em um ponto de código de vários bytes possui o número de bytes codificados dentro dele e os outros bytes no ponto de código têm o bit mais alto definido, mas não o próximo mais alto. Enquanto os pontos de código de byte único não têm o conjunto de bits mais alto.

Python 3, 82 bytes

import math
lambda x:[ord(i)<128and 1or int((math.log2(ord(i))-1)//5+1)for i in x]

Isso é muito mais longo que a outra resposta do Python e a maioria das outras respostas, mas usa uma abordagem que envolve logaritmos que eu ainda não vi.

Uma função anônima que recebe entrada, via argumento, como uma sequência e retorna uma lista.

Experimente no Ideone

Como funciona

Esse método depende da maneira como o UTF-8 codifica o ponto de código de um caractere. Se o ponto de código for menor que 128, o caractere será codificado como em ASCII:

0xxxxxxx

Onde x representa os bits do ponto de código. No entanto, para pontos de código maiores ou iguais a 128, o primeiro byte é preenchido com o mesmo número de 1s que o número total de bytes e os bytes subsequentes são iniciados 10. Os bits do ponto de código são então inseridos para fornecer a menor seqüência multibyte possível e os bits restantes se tornam 0.

No. of bytes  Format
1             0xxxxxxx
2             110xxxxx 10xxxxxx
3             1110xxxx 10xxxxxx 10xxxxxx
4             11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
...           ...

e assim por diante.

Agora, pode-se notar que, para cada número de bytes n, o limite superior para o número de bits do ponto de código é dado por(-n+7)+6(n-1) = 5n+1 . Portanto, o ponto de código limite superior cpara cada um né dado, em decimal, por c= 2^(5n+1). Reorganizar isso dán = (log2(c)-1)/5 . Portanto, para qualquer ponto de código, o número de bytes pode ser encontrado avaliando a expressão acima e, em seguida, assumindo o teto.

No entanto, isso não funciona para pontos de código no intervalo 64 <= c <= 127, pois a falta de um preenchimento1 devido à codificação semelhante a ASCII para caracteres de 1 byte significa que o limite superior incorreto é previsto e log2indefinido c = 0, o que acontece se um byte nulo está presente na entrada. Portanto, se c <= 127um valor de1 for retornado para n.

É exatamente isso que o código está fazendo; para cada caractere ina seqüência de caracteres x, o ponto de código é encontrado usando a ordfunção e o teto da expressão é encontrado usando a divisão de números inteiros em vez da flutuação 5e adicionando 1. Como o tipo float do Python sempre representa números inteiros x.0, mesmo após a divisão do número inteiro, o resultado é passado para a intfunção para remover o zero à direita. Se ord(i) <= 127, um curto-circuito lógico significa que 1é retornado. O número de bytes para cada caractere é armazenado como um elemento em uma lista e essa lista é retornada.

Java 10, 100 96 95 67 61 bytes

a->{for(var c:a)System.out.print(c.getBytes("utf8").length);}

-4 bytes removendo espaços porque isso é permitido nos comentários
-1 byte, mudando UTF-8para utf8
-28 bytes, passando de Java 7 para 8 (em a->{...}vez de void c(char[]i)throws Exception{...})
-3 bytes, recebendo a entrada como String-array em vez de character-array, e
-3 bytes indo do Java 8 para o 10 (em varvez de String)

Explicação:

Experimente online.

a->{                      // Method with String-array parameter and no return-type
  for(var c:a)            //  Loop over the input-array
    System.out.print(     //   Print:
      c.getBytes("utf8")  //    The bytes as array in UTF-8 of the current item,
       .length);}         //    and print the amount of bytes in this array

Julia, 34 bytes

s->s>""?map(sizeof,split(s,"")):[]

Esta é uma função anônima que aceita uma string e retorna uma matriz inteira. Para chamá-lo, atribua-o a uma variável.

A abordagem é bastante direta: se a entrada estiver vazia, a saída estará vazia. Caso contrário, mapeamos osizeof função, que conta o número de bytes em uma string, para cada substring de um caractere.

Experimente online! (inclui todos os casos de teste)

PHP, 92 57 bytes

Pensando bem, você pode fazer isso com muito menos folga:

<?php for(;$a=strlen(mb_substr($argv[1],$i++,1));)echo$a;

Experimente on-line, observe que isso é um pouco mais longo, pois usa stdin em vez de um argumento de programa.
Esta versão requer que você ignore os avisos enviados ao stderr, mas tudo bem .

versão antiga:
usa uma abordagem bastante diferente da outra resposta php. Baseia-se na falta de suporte nativo para strings de vários bytes no php.

<?php for($l=strlen($a=$argv[1]);$a=mb_substr($a,1);$l=$v)echo$l-($v=strlen($a));echo$l?:'';

Emacs Lisp, 55 49 bytes

(lambda(s)(mapcar'string-bytes(mapcar'string s)))

Primeiro disseca a string em uma lista de caracteres com (mapcar 'string s). A stringfunção no Emacs Lisp pega uma lista de caracteres e cria uma string a partir deles. Devido à maneira como o Emacs divide as strings com mapcar(ou seja, em uma lista de números inteiros, não caracteres ou strings), essa conversão explícita é necessária. Em seguida, mapeia a string-bytesfunção para essa lista de cadeias.

Exemplo:

(mapcar 'string "abc") ; => ("a" "b" "c")
(mapcar 'string-bytes '("a" "b" "c")) ; => (1 1 1) 

Casos de teste:

(mapcar
 (lambda(s)(mapcar'string-bytes(mapcar'string s)))
 '("!""Ciao""tʃaʊ""Adám""ĉaŭ""ĉaŭ""チャオ""""!±≡𩸽""\0"))
;; ((1) (1 1 1 1) (1 2 1 2) (1 1 2 1) (2 1 2) (1 2 1 1 2) (3 3 3) nil (1 2 3 4) (1))

Resposta antiga:

(lambda(s)(mapcar(lambda(s)(string-bytes(string s)))s))

Ungolfed:

 (lambda (s)
   (mapcar
    ;; we can't use string-bytes directly,
    ;; since Emacs mapcar yields a list of ints instead of characters
    ;; therefore we need a wrapper function here. 
    (lambda (s)
      (string-bytes (string s)))
    s))

Casos de teste:

(mapcar
 (lambda(s)(mapcar(lambda(s)(string-bytes(string s)))s))
 '("!""Ciao""tʃaʊ""Adám""ĉaŭ""ĉaŭ""チャオ""""!±≡𩸽""\0"))
;; ((1) (1 1 1 1) (1 2 1 2) (1 1 2 1) (2 1 2) (1 2 1 1 2) (3 3 3) nil (1 2 3 4) (1))

JavaScript (Nó), 27 bytes

s=>s.map(Buffer.byteLength)

Isso recebe a entrada como uma matriz de caracteres individuais e retorna uma matriz de contagens de bytes.

Bufferé um método de representar dados binários brutos. Buffer.byteLength (string) fornece o número de bytes na string. UTF-8 é a codificação padrão. Observe que apenas o Node.js possui buffers, não o JS do navegador. O equivalente aproximado do navegador é chamado Blob , com 31 bytes:

s=>s.map(e=>new Blob([e]).size)

Teste

Salve este arquivo e execute-o através do nó ou tente online .

var f =
  s=>s.map(Buffer.byteLength)

var tests = [
  ["!"],
  ["C","i","a","o"],
  ["t","ʃ","a","ʊ"],
  ["A","d","á","m"],
  ["ĉ","a","ŭ"],
  ["c","̂","a","u","̆"],
  ["チ","ャ","オ"],
  [],
  ["!","±","≡","𩸽"]
];

tests.forEach(test => {
  console.log(test, f(test));
});

Este deve ser o resultado:

$ node bytes.js
[ '!' ] [ 1 ]
[ 'C', 'i', 'a', 'o' ] [ 1, 1, 1, 1 ]
[ 't', 'ʃ', 'a', 'ʊ' ] [ 1, 2, 1, 2 ]
[ 'A', 'd', 'á', 'm' ] [ 1, 1, 2, 1 ]
[ 'ĉ', 'a', 'ŭ' ] [ 2, 1, 2 ]
[ 'c', '̂', 'a', 'u', '̆' ] [ 1, 2, 1, 1, 2 ]
[ 'チ', 'ャ', 'オ' ] [ 3, 3, 3 ]
[] []
[ '!', '±', '≡', '�' ] [ 1, 2, 3, 4 ]

Bash, 74 bytes

Golfe

xxd -p|fold -2|cut -c1|tr -d '89ab'|echo `tr -t '01234567cbef' '[1*]2234'`

Algoritmo

string de entrada hexdump, dobre 2 caracteres por linha, corte apenas o primeiro caractere

echo -ne '!±≡𩸽' | xxd -p|fold -2|cut -c1

2
c
b
e
8
a
f
a
b
b

(4 bits de ordem superior de cada byte de entrada como um caractere hexadecimal, um por linha)

Remova os "bytes de continuação" 0x80..0xBF

tr -d '89ab'

2
c

e


f

(o que resta, são 4 bits do primeiro byte de cada caractere unicode)

mapear os primeiros bits no comprimento do caractere, recolher a saída e imprimir

echo `tr -t '01234567cbef' '[1*]2234'`

1 2 3 4

Teste

 U() { xxd -p|fold -2|cut -c1|tr -d '89ab'|echo `tr -t '01234567cbef' '[1*]2234'`;}

 echo -ne '!' | U 
 1

 echo -ne 'Ciao' | U
 1 1 1 1

 echo -ne 'tʃaʊ' | U
 1 2 1 2

 echo -ne 'Adám' | U
 1 1 2 1

 echo -ne 'ĉaŭ' | U
 2 1 2

 echo -ne 'ĉaŭ' | U
 1 2 1 1 2

 echo -ne 'チャオ' | U
 3 3 3
 echo -ne '!±≡𩸽' | U
 1 2 3 4

 echo -ne "\x0" | U
 1

 echo -ne '' | U

PHP, 126 bytes

<?php $s=fgets(STDIN);echo $s!=''?implode(' ',array_map(function($x){return strlen($x);},preg_split('/(?<!^)(?!$)/u',$s))):'';

Experimente online!

C #, 89 82 bytes

I=>{var J="";foreach(char c in I){J+=Encoding.UTF8.GetByteCount(c+"");}return J;};

Um lambda C # simples que itera pela string e retorna a lista separada por espaço.

Editar: salvou 6 bytes graças a alguns comentários muito legais.

Haskell, 85 bytes

import Data.ByteString as B
import Data.ByteString.UTF8
(B.length.fromString.pure<$>)

Pitão, 17 bytes

mhxS+11+16,7lCdlC

Experimente online!

Use o ponto de código dos caracteres com algumas aritméticas.

C, 85 bytes.

l(unsigned char* c){while(*c){int d=(*c>>4)-11;
d=d<0?1:d+(d==1);putchar(48+d);c+=d;}}

Examina os 4 bits mais altos de cada byte para determinar a codificação e o número de bytes subsequentes a serem ignorados;

Fator, 57 87 82 80 bytes

[ [ dup zero? [ drop "1"] [ >bin length 4 /i 10 >base ] if ] { } map-as ""join ]

Explicado:

USING: kernel math math.parser sequences ;
IN: byte-counts

: string>byte-counts ( str -- counts )
  [                  ! new quotation: takes a char as a fixnum
    dup zero?        ! true if this is a NUL byte
    [ drop "1" ]     ! NUL bytes have length 1
    [ >bin           ! else, convert to binary string
      length         ! length of binary string
      4              ! the constant 4
      /i             ! integer division
      number>string  ! 4 -> "4"
    ] if             ! conditionally execute one of the previous quotations
  ]                  ! end
  { } map-as         ! map and clone-like an { } array
  "" join ;          ! join array of 1strings on empty string

Testes unitários:

USING: tools.test byte-counts ;
IN: byte-counts.tests

{ "1" } [ "!" string>byte-counts ] unit-test
{ "1111" } [ "Ciao" string>byte-counts ] unit-test
{ "1212"} [ "tʃaʊ" string>byte-counts ] unit-test
{ "1121" } [ "Adám" string>byte-counts ] unit-test
{ "212" } [ "ĉaŭ" string>byte-counts ] unit-test
{ "12112" } [ "ĉaŭ" string>byte-counts ] unit-test
{ "333" } [ "チャオ" string>byte-counts ] unit-test
{ "" } [ "" string>byte-counts ] unit-test
{ "1234" } [ "!±≡𩸽" string>byte-counts ] unit-test
{ "1" } [ "\0" string>byte-counts ] unit-test

Todos eles passam agora. c:

Swift 2.2, 67 52 50 bytes

for c in i.characters{print(String(c).utf8.count)}

Horrivelmente feio. Não há como obter o comprimento UTF-8 de um personagem no Swift, portanto, eu preciso percorrer a sequência de caracteres por caractere, converter o Characterem um Stringe encontrar o countcaractere único.String (ei, pelo menos, há um método para fazer isso). Procurando otimizações, possivelmente usando um scanner.

Revisão 1: salvou 15 bytes usando em countvez de underestimateCount().

Revisões 2: salvou outro caractere 2 usando um loop for-in em vez de um para cada fechamento.

Ferrugem, 53 bytes

|s:&str|for c in s.chars(){print!("{}",c.len_utf8())}

Rust possui utf-8 char primitives, iteradores e lambdas, portanto isso foi direto. Código do teste:

fn main() {
    let s = "Löwe 老虎 Léopard💖💖💖💖";
    let f =|s:&str|for c in s.chars(){print!("{}",c.len_utf8())};
    f(s);
}

Saídas

1211133112111114444 

jq, 26 caracteres

(Código de 23 caracteres + opção de linha de comando de 3 caracteres)

(./"")[]|utf8bytelength

Espero competir. Embora tenha utf8bytelengthsido adicionado 9 ++ meses antes desta pergunta, ainda não está incluído na versão lançada.

Exemplo de execução:

bash-4.3$ ./jq -R '(./"")[]|utf8bytelength' <<< 'tʃaʊ'
1
2
1
2

bash-4.3$ ./jq -R '(./"")[]|utf8bytelength' <<< 'ĉaŭ '
1
2
1
1
2
1

bash-4.3$ ./jq -R '(./"")[]|utf8bytelength' <<< 'チャオ'
3
3
3

bash-4.3$ ./jq -R '(./"")[]|utf8bytelength' <<< ''

bash-4.3$ ./jq -R '(./"")[]|utf8bytelength' <<< '!±≡𩸽'
1
2
3
4

C (gcc) , 53 bytes

k=49;f(char*s){*++s/64-2?k=puts(&k)+47:++k;*s&&f(s);}

Experimente online!

SmileBASIC, 69 bytes

DEF C B
WHILE I<LEN(B)Q=INSTR(BIN$(B[I],8),"0")I=I+Q+!Q?Q+!Q
WEND
END

Entrada é uma matriz de bytes.

O número de bytes em um caractere UTF-8 é igual ao número de 1bits iniciais no primeiro byte (a menos que não haja 1s, nesse caso, o caractere é de 1 byte). Para encontrar o número de 1s iniciais, o programa encontra o primeiro 0na representação binária e adiciona 1 se esse for 0.

0xxxxxxx - no leading ones, 1 byte
110xxxxx 10xxxxxx - 2 leading ones, 2 bytes
1110xxxx 10xxxxxx 10xxxxxx - 3 leading ones, 3 bytes
etc.

F #, 59 54 66 bytes

(s)=seq{for c in s->System.Text.Encoding.UTF8.GetByteCount([|c|])}

Tecnicamente, s é uma sequência de caracteres, mas acontece que há uma conversão implícita que permite que uma string seja passada.

Ao testar isso no console !±≡𩸽, ele divide o kanji em dois caracteres, cada um com 3 bytes de comprimento. Todos os outros casos de teste funcionam bem.

Edit: Acontece que importações comuns de namespace não estão implícitas. Até mais 12 caracteres.

05AB1E , 15 bytes

ÇεDžy‹i1ë.²<5÷>

Experimente online.
Cabeçalhoεé usado para cada um sobre todos os casos de teste;
Rodapéï]J]»para imprimir bem as listas de caracteres de saída (ï: decimais e caracteres para números inteiros;:]fechar if-else e para-eachJ;: unir dígitos juntos};: fechar cabeçalho foreach;:unir»por novas linhas).

Explicação:

Ç                   # Convert each character to its unicode value
 εD                 # Foreach over this list
      i             #  If the current item
     ‹              #  is smaller than
   žy               #  128
       1            #   Use 1
        ë           #  Else
         .²         #   Use log_2
           <        #   minus 1
            5÷      #   integer-divided by 5
              >     #   plus 1

Como o 05AB1E não possui nenhum built-in para converter caracteres na quantidade de bytes usados, eu uso Çpara converter os caracteres em seus valores unicode e, em cada um, faça o seguinte em pseudo-código:

if(unicodeValue < 128)
  return 1
else
  return log_2(unicodeValue-1)//5+1    # (where // is integer-division)

Inspirado na resposta Python 3 de @TheBikingViking .

Zsh , 41 bytes

for c (${(s::)1})set +o multibyte&&<<<$#c

Experimente online!

Como o Zsh reconhece UTF-8, dividimos a sequência em caracteres, desativamos o multibyte e imprimimos o comprimento de cada caractere.