Onaltılık bir sayıyı (herhangi bir boyutta) bir ikili sayıya dönüştürün.

Başlangıçta başında
bir POZİTİF onaltılı sayı girin0x . Geçerli bir giriş daima aşağıdaki regex eşleşir: 0x[0-9a-fA-F]+. Giriş geçerli bir onaltılık sayı değilse , yani bu normal ifadeyle eşleşmeyen herhangi bir şey değilse, çıktı olmalıdır 0.

Çıktı
İkili biçime dönüştürülen onaltılık.

Orijinal Kod-Golf Kuralları Kazanma , En az ısırık miktarı (bytes).

Örnekler

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 bayt

.B&qr0<z2"0x"vz

Açıklama:

             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 odası

0xOP'de kural açıklaması ( küçük harf olması gerekir) ile r013 bayt kaldırabilirsiniz .

.B&q<z2"0x"vz

Python 2, 67 62 60 59 bayt

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

Çevrimiçi deneyin!

Geçersiz girişte hata yapan sürüm (27 bayt):

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

Çevrimiçi deneyin!

05AB1E , 11 bayt

Î2£„0xQi¹Hb

Çevrimiçi deneyin!

açıklama

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

Toplu, 402 bayt

@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%

STDIN üzerine girdi alır. 8 satır daha sonra giriş doğrulamasında çoğunlukla boşa harcanır, bu nedenle ilginç satırlar, her bir onaltılık basamağı ikili eşdeğeriyle değiştiren, ancak Toplu sınırlamalar nedeniyle ., tüm .s ve satır 14'ü silen bir satır 12, satır ile değiştirir. önde gelen 0'ları kaldırır. Ancak bu gibi girişler için başarısız olur, bu 0x0yüzden 0 yerine çıkış olduğu anlamına gelir.

PHP, 66 65 63 bayt

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

boru olarak çalıştırmak -F.

Olmadan 0x, en kötü sorun hem olurdu hexdecve base_convertsadece onaltılık olmayan karakterler görmezden; fakat bununla birlikte, yine de açık bir geçerlilik kontrolü olmalıdır.

45 bayt olmadan 0x:

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

JavaScript (ES6), 109 108 bayt

Herhangi bir giriş boyutu için çalışır.

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

Test senaryoları

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 bayt

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

Retina , 149 bayt

.
;$&
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*

(sondaki yeni satıra dikkat edin)

Çevrimiçi deneyin!

İşte 7 baytlık bir maliyetle alternatif bir çözüm: Deneyin!

perl, 25

(kod 24 + 1 bayrak -n)

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

JavaScript (ES6), 116 111 bayt

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

53 bit hassasiyetle sınırlı değildir. Düzenleme: Rakam dönüşümümü yeniden yazarak 5 bayt kaydedildi, bu da benim dil gereksinimlerimi ES6'ya düşürüyor.

8086 makine kodu - 63 bayt

125 karaktere kadar herhangi bir giriş için çalışır (DOS'ta maksimum komut satırı uzunluğu)

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 bayt

( Herhangi bir boyuttaki girdileri işlemediği için rekabet etmiyor ; Örnek girişlerle şanslıydım)

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 bayt

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

Çevrimiçi deneyin!

açıklama

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 karakter

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 bayt

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

Javascript, 63 bayt

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