10

Convierta un número hexadecimal (de cualquier tamaño) en un número binario.

Ingrese
un número hexadecimal POSITIVO con un 0xal principio. Una entrada válida siempre coincidirá con la siguiente expresión regular: 0x[0-9a-fA-F]+. Si la entrada no es un número hexadecimal válido, es decir, cualquier cosa que no coincida con esta expresión regular, la salida debería serlo 0.

Salida
El hexadecimal convertido a binario.

Reglas originales ganadoras del código de golf, menor cantidad de bocados (bytes).

Ejemplos

IN: 0x12
OUT: 10010

IN: 0xFF
OUT: 11111111

IN: 0XFF
OUT: 0

IN: #0ac4
OUT: 0

IN: 0x00101011
OUT: 100000001000000010001

IN: 0x525600
OUT: 10100100101011000000000

IN: 0x58f70555118ec400
OUT: 101100011110111000001010101010100010001100011101100010000000000

IN: 0x6669795966AF3000
OUT: 110011001101001011110010101100101100110101011110011000000000000

IN: 0b018474
OUT: 0

IN: 9577383
OUT: 0

IN: -483355
OUT: 0

IN: -0xf9ad92
OUT: 0

code-golf base-conversion

— Hashim Kayani
fuente

77

Cuando dice "Si la entrada no es un número hexadecimal válido", ¿qué tipo de cosas puede ser? ¿Un número en una base diferente? ¿Un objeto no numérico? ¿Se evalúa algún objeto hecho para bloquear el programa, posiblemente de una manera no capturable? Realmente, habría sugerido evitar la validación de entrada; se siente como un desafío de camaleón .

— xnor

2

Inferir reglas de los casos de prueba no está bien y es probable que el desafío se cierre como poco claro. Además de eso, los ejemplos no son claros para mí. "# 0ac4" hace que parezca que se pueden incluir caracteres adicionales.

— xnor

1

Todavía no tengo claro después de la edición qué entradas son posibles. ¿ #0ac4Sigue siendo un caso de prueba válido?

— xnor

55

Su segundo caso de prueba no coincide con su expresión regular ( Xes mayúscula).

— Dada

1

¿Tenemos que ocuparnos de los ceros a la izquierda? ¿Podemos mostrar algo como00011010

— user41805

3

Pyth, 15 bytes

.B&qr0<z2"0x"vz

Explicación:

             vz  Evaluate the input as a literal, to get a number (casts to integer for hexadecimal input)
      <z2        Select the first two characters of (string) input
    r0           cast to lowercase (0X -> 0x)
   q     "0x"    check whether the text starts with "0x" or "0X" (negative numbers don't) 
  &              If it does, return the casted number
.B               and convert to binary string

Banco de pruebas

Con una aclaración de reglas (que 0xdebe estar en minúsculas) en el OP, puede eliminar r013 bytes.

.B&q<z2"0x"vz

— Steven H.
fuente

7

Python 2, 67 62 60 59 bytes

n=input()
try:print bin(int(n,n[1]<'x'))[2:]
except:print 0

Pruébalo en línea!

Versión que produce errores en una entrada no válida (27 bytes):

lambda n:bin(int(n,16))[2:]

Pruébalo en línea!

— adicto a las matemáticas
fuente

2

05AB1E , 11 bytes

Î2£„0xQi¹Hb

Pruébalo en línea!

Explicación

Î             # initialize stack with 0 and push input
 2£           # get the first 2 chars of input
   „0xQ       # compare to "0x"
       i      # if equal
        ¹H    # convert input from base-16 to base-10
          b   # convert to binary

— Emigna
fuente

No funciona con el caso de prueba 0XFF.

— Okx

@Okx: Tanto la expresión regular como la sección de entrada de la pregunta indican que la entrada correcta comienza, 0xpor lo que diría que el caso de prueba específico está mal.

— Emigna

1

Ah sí, no me di cuenta de eso.

— Okx

9 bytes usando el nuevoÅ? o 10 bytes usando el legado .

— Kevin Cruijssen

1

Lote, 402 bytes.

@echo off
set/ps=
set r=0
if not %s:~0,2%==0x goto g
if %s%==0x goto g
if %s:0=%==x goto g
set t=%s%
for %%h in (0 1 2 3 4 5 6 7 8 9 a b c d e f)do call set t=%%t:%%h=%%
if not %t%==x goto g
set s=%s:~2%
for %%h in (0.0000 1.0001 2.0010 3.0011 4.0100 5.0101 6.0110 7.0111 8.1000 9.1001 a.1010 b.1011 c.1100 d.1101 e.1110 f.1111)do call set s=%%s:%%~nh=%%~xh%%
set r=%s:.=%
:g
echo %r:*1=1%

Toma entrada en STDIN. Las 8 líneas se desperdician principalmente en la validación de entrada, por lo que las líneas interesantes son la línea 11, que reemplaza cada dígito hexadecimal con su equivalente binario, pero debido a las limitaciones de Batch, con una .línea inicial, 12, que elimina todos los .s, y la línea 14 , que elimina los ceros iniciales. Sin embargo, esto falla para entradas como, 0x0por lo tanto, "invalido" las que significa que 0 se emite en su lugar.

— Neil
fuente

1

PHP, 66 65 63 bytes

<?=decbin(hexdec(preg_filter("#^0x([a-f\d]+$)#i","$1",$argn)));

correr como tubería con -F.

Sin el 0x, el problema más grave sería que tanto hexdecy base_convertsimplemente ignorar caracteres que no son hexagonal; pero con esto, debe haber una verificación de validez explícita de todos modos

45 bytes sin el 0x:

<?=decbin(ctype_xdigit($argn)*hexdec($argn));

— Titus
fuente

echo stristr($a=$argn,"0X")==$a?decbin(hexdec(ltrim($a,Xx0))):0;¿Es esta una buena alternativa? Debería funcionar para los casos de prueba dados

— Jörg Hülsermann

@ JörgHülsermann: Es una buena alternativa, y para todos los que trabajan Está dado casos de prueba, pero lo hace no comprobar el valor hexadecimal para la validez (ver mi comentario sobre hexdece base_convert).

— Titus

Lo sé y creo que la pregunta es una broma con los casos de prueba dados.

— Jörg Hülsermann

1

echo decbin(hexdec(preg_filter("#^0x([a-f\d]+$)#i","$1",$argn)));

— Christoph

-2 Bytes en <?=lugar de la echo opción -F

— Jörg Hülsermann

0

JavaScript (ES6), 109108 bytes

Funciona para cualquier tamaño de entrada.

s=>/1.*|0$/.exec((/^0x([\da-f]+)$/i.exec(s)||'_0')[1].replace(/./g,d=>(+`0x1${d}`).toString(2).slice(1)))[0]

Casos de prueba

Mostrar fragmento de código

let f =

s=>/1.*|0$/.exec((/^0x([\da-f]+)$/i.exec(s)||'_0')[1].replace(/./g,d=>(+`0x1${d}`).toString(2).slice(1)))[0]

console.log(f('0x12'));               // OUT: 10010
console.log(f('0XFF'));               // OUT: 11111111
console.log(f('#0ac4'));              // OUT: 0
console.log(f('0x00101011'));         // OUT: 100000001000000010001
console.log(f('0x525600'));           // OUT: 10100100101011000000000
console.log(f('0x58f70555118ec400')); // OUT: 101100011110111000001010101010100010001100011101100010000000000
console.log(f('0x6669795966AF3000')); // OUT: 110011001101001011110010101100101100110101011110011000000000000
console.log(f('0b018474'));           // OUT: 0
console.log(f('9577383'));            // OUT: 0
console.log(f('-483355'));            // OUT: 0
console.log(f('-0xf9ad92'));          // OUT: 0

Expandir fragmento

— Arnauld
fuente

Hmm ... 2 golfistas experimentados que presentan soluciones JS más del doble de tiempo que el mío me hace preguntarme si me he perdido algo en el desafío.

— Shaggy

@Shaggy Todo depende de la interpretación de la primera línea del desafío. Di por sentado que 'de cualquier tamaño' era un requisito definitivo, y aparentemente Neil también.

— Arnauld

@Shaggy Solo para aclarar a todos: su enfoque funciona para hasta 0x1fffffffffffff- aka Number.MAX_SAFE_INTEGER- y devuelve resultados redondeados más allá de eso. Por suerte, los dos casos de prueba grandes se redondean correctamente.

— Arnauld

Huh, no me di cuenta de que el código de @ Shaggy funcionó por accidente; Supongo que debería haber contado la distancia entre el primer y el último 1bit del resultado. Por cierto, ¿necesitas $el primer regexp?

— Neil

@Neil, no creo que pueda deshacerme de esto $. La idea es obtener el cero final si no hay 1nada en el resultado.

— Arnauld

0

REXX, 45 bytes

arg '0X' n
if n>'' then say x2b(n)
else say 0

— idrougge
fuente

0

Retina , 149 bytes

.
;$&
T`L`l
f
71
e
70
d
61
c
60
b
51
a
50
9
41
8
40
7
31
6
30
5
21
4
20
3
11
2
10
;(\d{4})
$1
;(\d{3})
0$1
;(\d\d)
00$1
;
000
^(?!0{7}x).*
0
0{7}x0*

(tenga en cuenta la nueva línea final)

Pruébalo en línea!

Aquí hay una solución alternativa al costo de 7 bytes: ¡ Pruébelo!

— usuario41805
fuente

Ligeramente golfizado . Enfoque alternativo .

— Neil

0

perl, 25

(código 24 + 1 bandera -n)

printf"%8b",/^0x/i?hex:0

— Toto
fuente

0

JavaScript (ES6), 116 111 bytes

f=
s=>/^0x[\da-f]+$/i.test(s)?s.replace(/./g,c=>parseInt(4+c,36).toString(2).slice(-4)).replace(/0+10*(.)/,'$1'):0

<input oninput=o.textContent=f(this.value)><pre id=o>0

Expandir fragmento

No limitado a 53 bits de precisión. Editar: ahorré 5 bytes al reescribir mi conversión de dígitos, lo que también reduce mis requisitos de idioma a ES6.

— Neil
fuente

Puede reducir la longitud en 13 bytes evaluando cada carácter como el valor hexadecimal. Pruébelo en línea

— fəˈnɛtɪk

@ fəˈnɛtɪk Eso no resuelve la pregunta planteada.

— Neil

Aquí, eliminé los ceros iniciales de la primera conversión. Pruébelo en línea aún 2 bytes más corto.

— fəˈnɛtɪk

@ fəˈnɛtɪk Lo combiné con la respuesta de Arnauld y lo reduje a 103: ¡ Pruébelo en línea!

— Neil

@ fəˈnɛtɪk Espera, eso no funciona para el quinto caso de prueba 0x00101011, lo siento.

— Neil

0

Código de máquina 8086 - 63 bytes

Funciona para cualquier entrada de hasta 125 caracteres (la longitud máxima de la línea de comando en DOS)

00000000  be 82 00 bf 3f 01 89 fa  ad 3d 30 78 75 24 ac 3c  |....?....=0xu$.<|
00000010  0d 74 22 2c 30 3c 09 76  08 24 df 2c 07 3c 0f 77  |.t",0<.v.$.,.<.w|
00000020  11 b1 04 c1 e0 0c d0 e4  0f 92 c0 0c 30 aa e2 f6  |............0...|
00000030  eb dc ba 3d 01 b0 24 aa  b4 09 cd 21 c3 30 24     |...=..$....!.0$|
0000003f

— usuario5434231
fuente

0

JavaScript (ES6), 53 52 49 50 52 45 bytes

(No compite ya que no maneja entradas de ningún tamaño; tuve suerte con las entradas de muestra)

f=

h=>+/^0x[\da-f]+$/i.test(h)&&(+h).toString(2)

console.log(f`0x12`);
console.log(f`0XFF`);
console.log(f`#0ac4`);
console.log(f`0x00101011`);
console.log(f`0x525600`);
console.log(f`0x58f70555118ec400`);
console.log(f`0x6669795966AF3000`);
console.log(f`0b018474`);
console.log(f`9577383`);
console.log(f`-483355`);
console.log(f`-0xf9ad92`);

Expandir fragmento

— Lanudo
fuente

0

CJam , 24 bytes

q2/("0x"={seu:~Gb2bo}&;0

Pruébalo en línea!

Explicación

q      e# Read the input
2/     e# Split it into 2-length segments
(      e# Pull out the first segment
"0x"=  e# Check if it equals "0x"
{      e# If it does, run this block:
 s     e#  Join the segments back together
 eu    e#  Make the string uppercase
 :~    e#  Eval each character (A-K are 10-20)
 Gb    e#  Convert from base 16 to base 10
 2b    e#  Convert to base 2
 o     e#  Output the binary number
}&     e# (end of block)
;0     e# Delete the top stack element and push 0. If the block was run, nothing is left
       e# on the stack, so the program terminates with an error before pushing 0.

— Gato de negocios
fuente

0

JavaScript (ES6), 107 caracteres

f=
b=>/0x[\da-f]+$/i.test(b)&&b.match(/[\da-f](?!x)/gi).map(x=>((+('0x1'+x)).toString(2)).slice(-4)).join('')||0

console.log(f('0x1f'))
console.log(f('0x6669795966AF3000'))

Expandir fragmento

— Tomás Langkaas
fuente

0

Perl 6 , 35 bytes

{(m/^0x(.+)/&&:16(~$0)//0).base(2)}

— Sean
fuente

0

Javascript, 63 bytes

f=
x=>0|/^0x[A-Fa-f0-9]+$/.test(x)&&Number.parseInt(x).toString(2)

— Steve Bennett
fuente

Hexadecimal a Binario

Pyth, 15 bytes

Python 2, 67 62 60 59 bytes

05AB1E , 11 bytes

Lote, 402 bytes.

PHP, 66 65 63 bytes

JavaScript (ES6), 109108 bytes

Casos de prueba

REXX, 45 bytes

Retina , 149 bytes

perl, 25

JavaScript (ES6), 116 111 bytes

Código de máquina 8086 - 63 bytes

JavaScript (ES6), 53 52 49 50 52 45 bytes

CJam , 24 bytes

JavaScript (ES6), 107 caracteres

Perl 6 , 35 bytes

Javascript, 63 bytes