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

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

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!

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

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.

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

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

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

REXX, 45 bytes

arg '0X' n
if n>'' then say x2b(n)
else say 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!

perl, 25

(código 24 + 1 bandera -n)

printf"%8b",/^0x/i?hex: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

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.

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

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

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.

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

Perl 6 , 35 bytes

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

Javascript, 63 bytes

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