10

Converti un numero esadecimale (di qualsiasi dimensione) in un numero binario.

Immettere
un numero esadecimale POSITIVO con 0xa all'inizio. Un ingresso valido corrisponde sempre la seguente espressione regolare: 0x[0-9a-fA-F]+. Se l'input non è un numero esadecimale valido, ovvero qualsiasi cosa non corrisponda a questa regex, l'output dovrebbe essere 0.

Output
Esadecimale convertito in binario.

Vincere le
regole originali del Code-Golf, il minor numero di punture (bytes).

Esempi

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
fonte

7

Quando dici "Se l'input non è un numero esadecimale valido", che tipo di cose può essere? Un numero in una base diversa? Un oggetto non numerico? Qualche oggetto fatto per bloccare il programma viene valutato, possibilmente in modo non catchable? Davvero, avrei suggerito di evitare affatto la convalida dell'input; sembra una sfida camaleontica .

— xnor

2

Il trasferimento delle regole dai casi di test non è corretto e probabilmente la sfida verrà chiusa come poco chiara. Oltre a ciò, gli esempi non sono chiari per me. "# 0ac4" sembra che qualsiasi personaggio extra possa essere incluso.

— xnor

1

Non sono ancora chiaro dopo la modifica quali input sono possibili. È #0ac4ancora un caso di test valido?

— xnor

5

Il tuo secondo testcase non corrisponde al tuo regex ( Xè in maiuscolo).

— Dada,

1

Dobbiamo occuparci degli zeri iniziali? Possiamo emettere qualcosa del genere00011010

— user41805

3

Pyth, 15 byte

.B&qr0<z2"0x"vz

Spiegazione:

             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

Con un chiarimento delle regole (che 0xdeve essere in minuscolo) nell'OP, è possibile rimuovere r0per 13 byte.

.B&q<z2"0x"vz

— Steven H.
fonte

7

Python 2, 67 62 60 59 byte

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

Provalo online!

Versione che presenta errori nell'input non valido (27 byte):

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

Provalo online!

— drogato di matematica
fonte

2

05AB1E , 11 byte

Î2£„0xQi¹Hb

Provalo online!

Spiegazione

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

Non funziona con il test case 0XFF.

— Okx,

@Okx: Sia la regex che la sezione di input della domanda indicano che l'input corretto inizia con 0xquindi direi che il caso di test specifico è sbagliato.

— Emigna,

1

Ah sì, non me ne sono accorto.

— Okx,

9 byte utilizzando il nuovoÅ? o 10 byte utilizzando ancora l'eredità .

— Kevin Cruijssen,

1

Lotto, 402 byte

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

Accetta input su STDIN. 8 righe vengono quindi in gran parte sprecate durante la convalida dell'input, quindi le righe interessanti sono la riga 11, che sostituisce ogni cifra esadecimale con il suo equivalente binario, ma a causa delle limitazioni di Batch, con una .linea iniziale 12, che elimina tutte le .s, e la riga 14 , che rimuove gli 0 iniziali. Tuttavia, ciò non riesce per input come quelli, 0x0quindi "invalidare" quelli che indicano invece 0 viene emesso.

— Neil
fonte

1

PHP, 66 65 63 byte

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

correre come tubo con -F.

Senza il 0x, il problema peggiore sarebbe che entrambi hexdece base_convertsemplicemente ignorano i caratteri che non sono esadecimali; ma con esso, deve esserci comunque un controllo esplicito della validità.

45 byte senza 0x:

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

— Titus
fonte

echo stristr($a=$argn,"0X")==$a?decbin(hexdec(ltrim($a,Xx0))):0;È una bella alternativa? Dovrebbe funzionare per le date prove

— Jörg Hülsermann,

@ JörgHülsermann: è una bella alternativa e funziona per tutti i casi di test dati , ma non verifica la validità del valore esadecimale (vedere il mio commento su hexdece base_convert).

— Tito

Lo so e penso che la domanda sia uno scherzo con le prove fornite.

— Jörg Hülsermann,

1

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

— Christoph,

-2 byte <?=invece di echo con l'opzione -F

— Jörg Hülsermann,

0

JavaScript (ES6), 109 108 byte

Funziona con qualsiasi dimensione di input.

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

Casi test

Mostra snippet di codice

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

Espandi frammento

— Arnauld
fonte

Hmm ... 2 golfisti esperti che hanno presentato soluzioni JS più del doppio, purché la mia mi chieda se ho perso qualcosa nella sfida.

— Shaggy,

@Shaggy Tutto dipende dall'interpretazione della prima linea della sfida. Ho dato per scontato che "di qualsiasi dimensione" fosse un requisito definito - e apparentemente anche Neil.

— Arnauld,

@Shaggy Solo per chiarire per tutti: il tuo approccio funziona fino a 0x1fffffffffffff- aka Number.MAX_SAFE_INTEGER- e restituisce risultati arrotondati oltre. Per fortuna, i due grandi casi di test sono arrotondati correttamente.

— Arnauld,

Eh, non mi ero reso conto che il codice di @ Shaggy funzionava per caso; Immagino che avrei dovuto contare la distanza tra il primo e l'ultimo 1bit nel risultato. A proposito, ti serve $il primo regexp?

— Neil,

@Neil Non penso di potermi liberare di questo $. L'idea è quella di ottenere lo zero finale se non c'è alcun 1risultato nel risultato.

— Arnauld,

0

REXX, 45 byte

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

— idrougge
fonte

0

Retina , 149 byte

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

(nota la nuova riga finale)

Provalo online!

Ecco una soluzione alternativa al costo di 7 byte: provala!

— user41805
fonte

Leggermente golf . Approccio alternativo .

— Neil,

0

perl, 25

(codice 24 + 1 flag -n)

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

— Toto
fonte

0

JavaScript (ES6), 116 111 byte

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

Espandi frammento

Non limitato a 53 bit di precisione. Modifica: salvato 5 byte riscrivendo la conversione delle mie cifre, riducendo anche i miei requisiti linguistici a ES6.

— Neil
fonte

È possibile ridurre la lunghezza di 13 byte valutando ciascun carattere come valore esadecimale. Provalo online

— f 20nɛtɪk,

@ fəˈnɛtɪk Questo non risolve la domanda come posta.

— Neil,

Qui, ho rimosso gli zero iniziali dalla prima conversione Provalo online ancora più corto di 2 byte.

— fəˈnɛtɪk,

@ fəˈnɛtɪk L'ho combinato con la risposta di Arnauld e l'ho portato a 103: Provalo online!

— Neil,

@ fəˈnɛtɪk Aspetta, non funziona per il quinto caso di test 0x00101011, scusa.

— Neil,

0

8086 codice macchina - 63 byte

Funziona con qualsiasi input fino a 125 caratteri (la lunghezza massima della riga di comando 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

— user5434231
fonte

0

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

(Non competitiva in quanto non gestisce input di qualsiasi dimensione; sono stato fortunato con gli input di esempio)

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

Espandi frammento

— ispido
fonte

0

CJam , 24 byte

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

Provalo online!

Spiegazione

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.

— Gatto di affari
fonte

0

JavaScript (ES6), 107 caratteri

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

Espandi frammento

— Tomas Langkaas
fonte

0

Perl 6 , 35 byte

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

— Sean
fonte

0

Javascript, 63 byte

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

— Steve Bennett
fonte

Da esadecimale a binario

Pyth, 15 byte

Python 2, 67 62 60 59 byte

05AB1E , 11 byte

Lotto, 402 byte

PHP, 66 65 63 byte

JavaScript (ES6), 109 108 byte

Casi test

REXX, 45 byte

Retina , 149 byte

perl, 25

JavaScript (ES6), 116 111 byte

8086 codice macchina - 63 byte

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

CJam , 24 byte

JavaScript (ES6), 107 caratteri

Perl 6 , 35 byte

Javascript, 63 byte