Hexadecimal to Binary

Question

Convert a hexadecimal number (of any size) into a binary number.

Input
A POSITIVE hexadecimal number with a 0x in the beginning. A valid input will always match the following regex: 0x[0-9a-fA-F]+. If the input is not a valid hexadecimal number, that is, anything not matching this regex, the output should be 0.

Output
The hexadecimal converted to binary.

Winning
Original Code-Golf Rules, Lowest amount of bites (bytes).

Examples

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

IN: 0xG
OUT: 0

IN: 0x0xa
OUT: 0

Answer 1

Python 2, 67 62 60 59 bytes

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

Try it online!

Version that errors on invalid input (27 bytes):

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

Try it online!

Answer 2

Pyth, 15 bytes

.B&qr0<z2"0x"vz

Explanation:

             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

Test Suite

With a rules clarification (that 0x must be lowercase) in the OP, you can remove r0 for 13 bytes.

.B&q<z2"0x"vz

Answer 3

Swift 5.10, 102 101 bytes

Uses Swift regex literals introduced in 5.7, after the question was asked.

let c={(s:String)in s.contains(/^0x[0-9a-fA-F]+$/) ?.init(Int(s.dropFirst(2),radix:16)!,radix:2):"0"}

Explanation/Long version

func convert(_ string: String) -> String {
    // Check input matches format
    if string.contains(/^0x[0-9a-fA-F]+$/) {
        // Prep input to be converted
        let stringWithout0xPrefix = string.dropFirst(2)
        // Conversion work
        let hexStringAsDecimal = Int(stringWithout0xPrefix, radix: 16)!
        let decimalStringAsBoolean = String(hexStringAsDecimal, radix: 2)
        return decimalStringAsBoolean
    } else {
        // Default case
        return "0"
    }
}

Answer 4

05AB1E, 11 bytes

Î2£„0xQi¹Hb

Try it online!

Explanation

Î             # 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

Answer 5

JavaScript (Node.js), 92 bytes

x=>/^0000x0*([01]+)$|/i.exec(x.replace(/./g,c=>('0x1'+c-0||1+c).toString(2).slice(1)))[1]||0

Try it online!

no 2⁵³ limit

JavaScript (Node.js), 37 bytes

to compare with Shaggy's solution

x=>(/x/i.test(x[1])*x||0).toString(2)

Try it online!

2⁵³ limit, issue when x end with space

Answer 6

Batch, 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%

Takes input on STDIN. 8 lines are then mostly wasted on input validation, so the interesting lines are line 11, which replaces each hex digit with its binary equivalent, but due to Batch limitations, with a leading ., line 12, which deletes all the .s, and line 14, which removes leading 0s. However this fails for inputs like 0x0 so I "invalidate" those which means 0 is output instead.

Answer 7

Perl 6, 35 bytes

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

Answer 8

PHP, 66 65 63 bytes

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

run as pipe with -F.

Without the 0x, the worst problem would be that both hexdec and base_convert simply ignore characters that are not hex; but with it, there has to be an explicit validity check anyway.

---

45 bytes without the 0x:

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

Answer 9

Python 3.11 - 59

Inspired by mathjunkie's

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

Using the new walrus operator := to save a newline byte to store the input, but having to use an extra byte for print()'s parentheses, keeping the total byte count equal to the original.

int(n, 16) would also accept "10" as valid input and print "10000" (ie. hex 0x10, dec 16), so we need some way to validate that it starts with 0x. I couldn't find a shorter way than the original ,n[1]<'x' since int(n, False) understands the "0x" prefix and int(n, True) raises a ValueError.

The [2:] is necessary since bin() always replies with leading 0b

Answer 10

PowerShell Core, 74 bytes

param($a)if($a-cmatch'^0x[0-9a-fA-F]+$'){[Convert]::ToString($a,2)}else{0}

Try it online!

Answer 11

REXX, 45 bytes

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

Answer 12

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*

(note the trailing newline)

Try it online!

Here is an alternate solution at the cost of 7 bytes: Try it!

Answer 13

perl, 25

(code 24 + 1 flag -n)

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

Answer 14

8086 machine code - 63 bytes

Works for any input up to 125 chars (the maximum command line length in 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

Answer 15

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

(Non-competing as it doesn't handle inputs of any size; I just got lucky with the sample inputs)

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

Answer 16

CJam, 24 bytes

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

Try it online!

Explanation

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.

Answer 17

JavaScript (ES6), 107 characters

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

Answer 18

Javascript, 63 bytes

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

Answer 19

Ruby -p, 44 bytes

~/^0x[0-9a-fA-F]+$/
$_=$&.hex.to_s 2rescue 0

Attempt This Online!

Answer 20

JavaScript (ES6), 116 111 110 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

Not limited to 53 bits of precision. Edit: Saved 5 bytes by rewriting my digit conversion, which also reduces my language requirements to ES6. Saved 1 byte thanks to @l4m2.

Answer 21

JavaScript (ES6), 109 108 107 bytes

-1 thanks to l4m2

Works for any input size.

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

Try it online!