Una cantidad de longitud variable (también conocida como VLQ o uintvar) es una forma de codificar un valor entero de hasta 28 bits utilizando solo tantos bytes como sea necesario. Esto se usó en formato de archivo MIDI como una forma de minimizar el tamaño de ciertos datos de eventos.

La forma en que funciona es bastante simple. Como una serie de bytes big-endian, el bit más significativo (MSB) de cada byte es un 1para indicar que sigue otro byte VLQ. Los 7 bits restantes de cada byte forman el valor decodificado.

Ejemplo (de Wikipedia):

[ 0x86, 0xc3, 0x17 ] => 106903

Referencias adicionales: Wikipedia , Some Guy .

Desafío:

Dada una cantidad de longitud variable, conviértala a su valor entero.

Entrada:

Una lista de uno a cuatro bytes o un tipo de valor de 32 bits que representa un VLQ válido de un entero.

Salida:

El valor entero de la entrada VLQ.

Reglas y puntuación:

• Este es el código de golf, por lo que gana la respuesta más corta en bytes para cada idioma .
• Se aplican las reglas estándar y las reglas de E / S predeterminadas .
• Lagunas prohibidas (por supuesto).
• Proporcione un enlace con una prueba para su código ( TIO.run , etc.).
• Se recomienda encarecidamente una explicación clara de su respuesta.
• Los elementos integrados que manejan esta conversión no están prohibidos, sin embargo, no usarlos es mucho más interesante.

Casos de prueba:

Input (VLQ)                   Output (int)

[                   0x00 ] => 0
[                   0x07 ] => 7
[                   0x7f ] => 127
[             0x81, 0x00 ] => 128
[             0xC0, 0x00 ] => 8192
[             0xff, 0x7f ] => 16383
[       0x81, 0x80, 0x00 ] => 16384
[       0x86, 0xc3, 0x17 ] => 106903
[       0xbd, 0x84, 0x40 ] => 1000000
[       0xff, 0xff, 0x7f ] => 2097151 
[ 0xC0, 0x80, 0x80, 0x00 ] => 134217728  
[ 0xFF, 0xFF, 0xFF, 0x7F ] => 268435455  

Nota: no es necesario que use literales hexadecimales para representar un byte como entrada o salida. Puede usar decimal literal ( [ 129, 128, 0 ]), entero ( 0x80818000) o cualquier otra representación razonable de byte / octeto si se adapta mejor a su plataforma. El formato es flexible siempre que represente 1-4 bytes / octetos.

¡Golf lejos!

APL (dzaima / APL) , 8 bytes

128(⊣⊥|)

Pruébalo en línea!

Cómo:

128(⊣⊥|) ⍝ Anonymous function
128   |  ⍝ Input modulo 128
    ⊣⊥   ⍝ Decoded from base 128

Pari / GP , 24 bytes

a->fromdigits(a%128,128)

Pruébalo en línea!

Wolfram Language (Mathematica) , 25 bytes

Fold[128#+#2&,#~Mod~128]&

Pruébalo en línea!

Wolfram Language (Mathematica) , 25 bytes

#~Mod~128~FromDigits~128&

Pruébalo en línea!

J , 10 bytes

128#.128|]

Pruébalo en línea!

Tomando inspiración de la respuesta APL de J Salle.

• 128|] El resto de los números de entrada divididos por 128
• 128#. Interpretado como los dígitos de un número base 128

Jalea , 6 bytes

%Ø⁷ḅØ⁷

Pruébalo en línea!

Equivalente a la respuesta de Alephalpha Pari / GP .

$n$$n \mod 128$$128$

05AB1E , 6 bytes

žy%žyβ

Pruébalo en línea!

128_^{$2^7$}

Stax , 8 bytes

å→♂á╣>nt

Ejecutar y depurarlo

Algoritmo:

• Convierta cada byte en una matriz de 7 bits de ancho fijo.
• Acoplar matrices de bits en uno.
• Convierta la matriz de bits nuevamente a número.

JavaScript (ES6), 29 bytes

-2 bytes gracias a @Shaggy

Toma la entrada como una matriz de bytes.

a=>a.map(p=c=>p=p<<7|c&127)|p

Pruébalo en línea!

APL + WIN, 22 bytes

Solicita un vector de enteros:

2⊥¯32↑,0 1↓⍉(8⍴2)⊤¯4↑⎕

Pruébalo en línea! Cortesía de Dyalog Classic.

Explicación:

¯4↑⎕ Pad the vector to 4 integers from the right.

⍉(8⍴2)⊤ Convert to a matrix of 8 bit values.

,0 1↓ drop the MSBs and flatten to a vector.

2⊥¯32↑ pad bit vector to 32 bits starting at LSB and convert back to integer.

Stax , 12 bytes

ü╫ôà¡k2Wù}a☺

¡Ejecútelo y depúrelo en staxlang.xyz!

Desempaquetado (14 bytes) y explicación:

rk128%128i^#*+
r                 Reverse 'cuz big-endian
 k                Fold from the left using block:
  128%              Modulize by 128
      128i^#        Push 128 to the power of (one plus the iteration index)
            *       Multiply
             +      Add to the total
                  Implicit print

Stax tiene una conversión de base integrada, pero solo funciona en cadenas. Sin embargo, casi funciona en listas de enteros; El problema está en el manejo de Stax de 0.

Una cadena es una lista de enteros. Cuando usa una lista como una cadena, los ceros se convierten automáticamente a 32 como una forma abreviada de espacios. Dado que la |bconversión integrada para la base trata su operando como una cadena en lugar de como una lista sin formato de enteros, cualquier caso con un cero fallará.

10 bytes, falla en ceros

Ç┘_A♥∙QZ►╣
{128%m128|b    Unpacked
{128%m         Modulize each by 128
      128|b    Convert from base 128

¡Ejecútelo y depúrelo en staxlang.xyz!

C (gcc) , 48 bytes

Toma un entero en orden big-endian como entrada, que es el mismo orden que una matriz de bytes.

f(i,j){for(j=0;j|=i&127,i&128;j<<=7,i>>=8);i=j;}

Pruébalo en línea!

C (gcc) , 53 bytes

Si se necesita una matriz de bytes:

f(c,j)char*c;{for(j=0;j|=*c&127,*c++&128;j<<=7);c=j;}

Pruébalo en línea!

MathGolf , 14 bytes

ê♣%hrx♣▬^mÅε*Σ

Entrada como enteros.

Pruébalo en línea.

Tengo la sensación de que esto puede ser más corto. Es un poco molesto que MathGolf tenga un byte incorporado de 1 byte para la constante 128, pero no conversión de base (excepto para binario / hexadecimal).

Explicación:

ê              # Take the inputs as integer-array
 ♣%            # Take modulo-128 on each value in this array
   h           # Push the length of the array (without popping the array itself)
    r          # Pop and push a list in the range [0, length)
     x         # Reverse the array to (length, 0]
      ♣▬       # Take 128 to the power of each value in this array
        ^      # Zip the two lists together to create pairs
         mÅ    # Map each pair to (using the following two commands):
           ε*  #  Reduce by multiplication (so basically the product of the pair)
             Σ # After multiplying each pair, take the total sum
               # (after which the entire stack joined together is output implicitly)

Python 3 , 58 49 bytes

-9 bytes gracias a @Chas y @ ar4093

lambda x:int("".join(bin(a|128)[3:]for a in x),2)

Pruébalo en línea!

o

lambda x:int("".join(f"{a%128:07b}"for a in x),2)

Pruébalo en línea!

Entrada a través de la lista de enteros.

La binfunción de Python agrega "0b" al comienzo de la cadena, por lo que deben eliminarse antes de que puedan concatenarse. Tampoco mantiene los ceros a la izquierda, por lo que si no hay ninguno (también conocido como el último byte), esos deben agregarse nuevamente. bien. Gracias a @Chas por descubrir que al configurar siempre el primer bit, puedo eliminar los primeros tres caracteres y listo.

Aparentemente (según @ ar4093) la formatfunción permite no solo no tener el prefijo '0b', sino también eliminar el primer bit y el relleno a 7 caracteres, todo al mismo tiempo.

PHP , 42 bytes

foreach($argv as$a)$r=$r<<7|$a&127;echo$r;

Pruébalo en línea! y verificar todos los casos de prueba .

Entrada a través de la línea de comando args, salida a STDOUT.

Japt , 10 8 bytes

Toma datos como una matriz de enteros.

muIÑ ìIÑ

Pruébalo o ejecuta todos los casos de prueba (encabezado en ambos conversos del formato de entrada utilizado en desafío)

Ahorró 2 bytes al inspirarse en la solución de alephalpha .

muIÑ ìIÑ     :Implicit input of integer array
m            :Map
 u           :  Modulo
  I          :    64
   Ñ         :    Multiply by 2
     ì       :Convert to decimal
      IÑ     :  From base 64*2

Carbón , 11 bytes

Ｉ↨﹪θ¹²⁸¦¹²⁸

Pruébalo en línea! El enlace es a la versión detallada del código. Toma la entrada como una matriz. Explicación:

   θ        Input array
  ﹪ ¹²⁸    Elementwise modulo 128
 ↨      ¹²⁸ Convert from base 128
Ｉ          Cast to string for implicit print

Python 2 , 42 bytes

f=lambda a:a>[]and a[-1]%128+f(a[:-1])*128

Pruébalo en línea!

Lote de Windows, 76 bytes

:a
@set/ax="%1&127",y=y*128+x
@if %2. neq . @shift&goto:a
@echo %y%

Pase los parámetros con el prefijo "0x" y el espacio entre ellos (por ejemplo, 0xC0 0x80 0x80 0x00).