Medidor de golfe de código © 2019

Hexdumps usados ​​com xxdalgo parecido com isto:

00000000: 666f 6f20 6261 7220 7370 616d 2065 6767  foo bar spam egg
00000010: 730a                                     s.

Sua tarefa é converter um hexdump neste formulário no número de bytes usados.

Regras:

• Falhas usuais proibidas.
• Isso é código-golfe , então a resposta válida mais curta em bytes vence.
• Você pode ou não incluir a nova linha no final do texto ( 0a). Isso significa que, se o hexdump terminar em uma nova linha ( 0a), essa entrada poderá ter sua saída reduzida em um.
• Uma entrada vazia (literalmente nada: lista vazia / string / etc.) Deve gerar 0.
• A entrada pode ser obtida de qualquer forma
• A entrada será ASCII válida sem caracteres de controle
• A entrada deve conter todo o hexdump

Casos de teste:

00000000: 4865 6c6c 6f2c 2077 6f72 6c64 2120 4865  Hello, world! He
00000010: 6c6c 6f2c 2077 6f72 6c64 210a            llo, world!.

retorna 28 ou 27

00000000: 0a                                       .

retorna 1 ou 0

00000000: 6368 616c 6c65 6e67 650a                 challenge.

retorna 10 ou 9

00000000: 4865 6c6c 6f2c 2077 6f72 6c64 21         Hello, world!

retorna 13

retorna 0 (literalmente nada: lista vazia / string / etc.)

Explicações seria bom para idiomas não-padrão.

Retina 0.8.2 , 8 bytes

.{51}

.

Experimente online! Explicação:

.{51}

Exclua os primeiros 51 caracteres de cada linha. (As linhas só podem ter entre 52 e 67 caracteres, portanto, isso sempre corresponde uma vez por linha.)

.

Conte os caracteres restantes que não são de nova linha.

7 bytes se a entrada vazia não tiver que ser suportada:

.{52}

Experimente online! Explicação:

.{52}

Exclua os primeiros 52 caracteres de cada linha. (As linhas só podem ter entre 52 e 67 caracteres, portanto, isso sempre corresponde uma vez por linha.)

Conte 1 mais que o número de caracteres restantes (incluindo novas linhas).

tcsh , 12 bytes

xxd -r|wc -c

Experimente online!

V (vim) , 7 bytes

Î51x
Ø.

Experimente online!

Explicação:

Î       " On every line...
 51x    "   Delete the first 51 characters
Ø.      " Count the number of remaining characters on any line

Hexdump:

00000000: ce35 3178 0dd8 2e                        .51x...

Retina , 7 bytes

Isso conta o número total de strings de linha única de comprimento 52. Talvez seja possível fazer algo semelhante %52,`., mas não encontrei uma maneira de corrigir isso.

w`.{52}

Experimente online!

APL (Dyalog Extended) , 18 bytes

Programa completo. Solicita a lista de strings (ou seja, de listas de caracteres).

2÷⍨≢∊(1↓≠⊆⊢)¨49↑¨⎕

Experimente online!

⎕ pronto

49↑¨ pegue os primeiros 49 caracteres de cada

(… )¨Aplique a seguinte função tácita a cada um:

 ⊢ o argumento

 ⊆ pique em séries de caracteres que são

 ≠ diferente do caractere de preenchimento (espaço)

 1↓ solte a primeira "palavra"

∊ ε nlist (achatar)

≢ registro

2÷⍨ dividir por dois

Gelatina , 5 bytes

Ẉ_51S

Um link monádico que aceita uma lista de linhas que produz a contagem de bytes inteiros.

Experimente online!

Quão?

Ẉ_51S - Link: list of lists of characters, H
Ẉ     - length of each (line in H)
  51  - literal fifty-one
 _    - subtract (vectorises)
    S - sum

C (gcc) , 64 55 bytes

r;s[];f(l){while(*s=0,gets(s),l=strlen(s))r+=l-51;l=r;}

Experimente online!

9 bytes raspados graças ao YSC!

Aqui está uma versão mais frágil inspirada na solução JavaScript de Arnauld, que provavelmente falha em entradas longas:

C (gcc) , 50 bytes

s[];f(l){l=read(0,s,1<<31);l=l?l/68*16+l%68-51:0;}

Experimente online!

Python 3, 48 46 bytes

lambda s:(len(s)or 51)+1-52*len(s.split('\n'))

A entrada é passada como uma sequência para a função. A função incrementa o comprimento da entrada (incluindo novas linhas) e subtrai 52 para cada linha.

Experimente online

Japt -x , 5 bytes

Entrada como uma matriz de linhas.

®Ê-51

Tente

®Ê-51     :Implicit input of array
®         :Map
 Ê        :  Length
  -51     :  Subtract 51
          :Implicit output of sum of resulting array

Perl 6 , 18 bytes

{.join.comb-51*$_}

Experimente online!

Anônimo Qualquer lambda que pega uma lista de linhas e retorna a soma do número de caracteres, subtraindo 51 para cada linha

05AB1E , 8 6 bytes

€g51-O

Experimente online!

Entrada como uma lista de strings.

€g     get lengths of each line
51-    subtract 51 from each
O      push the sum of the resulting list
       implicitly print

MathGolf , 7 6 bytes (não concorrente)

m£Ex-Σ

Não é concorrente (por enquanto), porque atualmente existe um erro no MathGolf para entradas de string contendo espaços. Eles são automaticamente transformados em uma lista (dividida por espaços). No TIO, substituí todos os espaços por umB para mostrar que ele funciona como pretendido.

Entrada como uma lista de strings.

-1 byte localizando um método para gerar 51 em 2 bytes (consulte o histórico para mais de 10 maneiras de fazê-lo em 3 bytes.)

Experimente online.

Explicação:

m    # Map each string in the (implicit) input-list
 £   #  Pop the string and get the length
E    # Push 15
 x   # Reverse, but keep it an integer
     # (NOTE: simply `51` would be interpret as two values on the stack: 5 and 1)
  -  # Subtract each of the lengths by this
Σ    # Take the sum of the list
     # (after which the entire stack joined together is output implicitly as result)

IBM / Lotus Notes Formula Language, 53 bytes

@Sum(@Length(@Explode(@Right(@Left(i;"  ");": ")))/2)

Não há TIO para a fórmula, então, aqui estão as capturas de tela dos casos de teste:

A fórmula está no campo calculado que fornece o valor após "Retornos".

Explicação

Esta é uma boa demonstração da maneira como a Formula aplicará recursivamente uma função a uma lista sem precisar de um loop. A fórmula está em um campo calculado no mesmo formato do campo de entrada editável `i '.

1. Comece no meio. @Lefte @Rightpermita que um delimitador de sequência ou um número de caracteres seja usado. Portanto, procuramos à direita :e depois à esquerda da primeira ocorrência de dois espaços. Como a Fórmula vê a nova linha como um separador de lista, ela será aplicada a cada linha da entrada.
2. @Explodeé o equivalente de uma splitfunção da fórmula e o padrão é espaço, ,ou ;. Novamente, é aplicado a cada linha do campo, mas desta vez os resultados são combinados em uma única lista.
3. @Lengthserá aplicado a cada membro da lista. Em cada caso, dividimos seu valor de retorno por 2.
4. @Sum a lista inteira e produza o resultado.

JavaScript (ES6), 34 bytes

s=>(n=s.length)&&(n/68<<4)+n%68-51

Experimente online!

Comentado

s =>                // s = input string
  (n = s.length) && // n = length of s; return 0 right away if n = 0 (special case)
  (n / 68 << 4) +   // otherwise compute the number of full lines and multiply it by 16
  n % 68 - 51       // add the length of the last line minus 51

Vermelho , 81 55 bytes

func[s][n: 0 foreach l s[n: n - 51 + length? l]max 0 n]

Experimente online!

Toma a entrada como uma lista de seqüências de caracteres.

JavaScript, 33 32 bytes

a=>a.map(x=>a=~~a+x.length-51)|a

Experimente Online!

Guardado 1 byte graças a Arnauld.

Befunge-98 (FBBI) , 16 bytes

"c- cw|r- dxx"=@

Experimente online!

Stax , 5 bytes

ôφß→ê

Execute e depure

Zsh , 36 bytes

Com os sinalizadores padrão do zsh:

for l (${(f)1})((c+=$#l-52))
<<<$[c]

Experimente online!

${(f)1}divide $1em novas linhas e descarta linhas vazias. Os $[ arithmetic expansion ]guardas contra a caixa vazia, quando o loop nunca se ajusta $c.

Zsh , 28 bytes

Com -o extendedglob:

<<<${#${(F)${(f)1}#?(#c52)}}

Experimente online!

(f)Divida em novas linhas, ${ #?(#c52)}remova 52 caracteres (F)iniciais, junte-se a novas linhas para que a contagem seja caractere em vez de listar, ${# }conte caracteres.

asm2bf , 135 bytes

Versão Golfed:

lbl 3
mov r2,51
lbl 1
in_ r1
dec r2
jz_ r1,4
jnz r2,1
lbl 2
in_ r1
jz_ r1,4
sub r1,10
jz_ r1,3
inc r3
jmp 2
lbl 4
out r3

Versão comentada:

lbl 3               ; Main loop - the kinda entry point

    mov r2, 51      ; Loop 51 times.
    lbl 1           ; Loop start.
        in_ r1      ; Read character
        dec r2      ; Decrement the loop accumulator.
        jz_ r1, 4   ; If zero was read, end.
        jnz r2, 1   ; If we still loop, loop again.

    lbl 2           ; Second loop, accumulating the result.
        in_ r1      ; Read a character.
        jz_ r1, 4   ; If character is zero, end the loop and print result.
        sub r1, 10  ; Decrement r1 by 10 for next check.
        jz_ r1, 3   ; If the character - 10 (the newline) is zero, jump to 3
        inc r3      ; Increment character read amount.
        jmp 2
lbl 4
    out r3          ; Print out the result as an ASCII character.