10

Converta um número hexadecimal (de qualquer tamanho) em um número binário.

Insira
um número hexadecimal POSITIVO com a 0xno início. A entrada válida sempre coincidir com o seguinte regex: 0x[0-9a-fA-F]+. Se a entrada não for um número hexadecimal válido, ou seja, qualquer coisa que não corresponda a esse regex, a saída deverá ser 0.

Saída
O hexadecimal convertido em binário.

Vencendo as
Regras Originais de Código-Golfe, Menor quantidade de mordidas (bytes).

Exemplos

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 você diz "Se a entrada não é um número hexadecimal válido", que tipos de coisas podem ser? Um número em uma base diferente? Um objeto não numérico? Algum objeto feito para travar o programa é avaliado, possivelmente de uma maneira não alcançável? Realmente, eu teria sugerido evitar a validação de entrada; parece um desafio de camaleão .

— Xnor

2

Inferir regras a partir de casos de teste não é bom e provavelmente o desafio será encerrado por não ser claro. Além disso, os exemplos não são claros para mim. "# 0ac4" faz parecer que qualquer caractere extra possa ser incluído.

— xnor

11

Ainda não estou claro após a edição quais entradas são possíveis. #0ac4Ainda é um caso de teste válido?

— Xnor

5

Seu segundo caso de teste não corresponde ao seu regex ( Xestá em maiúsculas).

— Dada

11

Precisamos cuidar dos zeros à esquerda? Podemos produzir algo como:00011010

— user41805

3

Pitão, 15 bytes

.B&qr0<z2"0x"vz

Explicação:

             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

Suíte de teste

Com um esclarecimento de regras (que 0xdeve estar em minúsculas) no OP, você pode remover r0por 13 bytes.

.B&q<z2"0x"vz

— Steven H.
fonte

7

Python 2, 67 62 60 59 bytes

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

Experimente online!

Versão que erros na entrada inválida (27 bytes):

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

Experimente online!

— viciado em matemática
fonte

2

05AB1E , 11 bytes

Î2£„0xQi¹Hb

Experimente online!

Explicação

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

Não funciona com o caso de teste 0XFF.

— Okx, 12/04/19

@ Ok: Tanto o regex como a seção de entrada da pergunta afirmam que a entrada correta começa com, 0xentão eu diria que o caso de teste específico está errado.

— Emigna

11

Ah sim, eu não percebi isso.

— Okx, 12/04/19

9 bytes usando o novoÅ? ou 10 bytes ainda usando o legado .

— Kevin Cruijssen 17/01/19

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%

Recebe entrada em STDIN. Em seguida, 8 linhas são desperdiçadas principalmente na validação de entrada; portanto, as linhas interessantes são a linha 11, que substitui cada dígito hexadecimal pelo seu equivalente binário, mas devido às limitações do Lote, com uma .linha inicial 12, que exclui todos os se .14 , que remove os 0s iniciais. No entanto, isso falha em entradas como 0x0essa, e eu "invalido" aquelas que significam que 0 é emitido.

— Neil
fonte

1

PHP, 66 65 63 bytes

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

correr como tubo com -F.

Sem o 0x, o pior problema seria que tanto hexdece base_convertsimplesmente ignorar caracteres que não são hex; mas com isso, deve haver uma verificação de validade explícita de qualquer maneira.

45 bytes sem o 0x:

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

— Titus
fonte

echo stristr($a=$argn,"0X")==$a?decbin(hexdec(ltrim($a,Xx0))):0;Esta é uma boa alternativa? Ele deve trabalhar para os casos de teste dadas

— Jörg Hülsermann

@ JörgHülsermann: boa alternativa It'sa e IT'S de trabalho para todos os dados de casos de teste, mas ele não verificar o valor hex para a validade (ver o meu comentário no hexdece base_convert).

— Titus

Eu sei e acho que a pergunta é uma piada com os casos de teste fornecidos.

— Jörg Hülsermann

11

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

— Christoph

-2 Bytes <?=istead de echo com opção -F

— Jörg Hülsermann

0

JavaScript (ES6), 109 108 bytes

Funciona para qualquer tamanho 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 teste

Mostrar snippet 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 snippet

— Arnauld
fonte

Hmm ... 2 golfistas experientes enviando soluções JS mais que o dobro do tempo que os meus me perguntam se perdi algo no desafio.

— Shaggy

@ Shagy Tudo depende da interpretação da primeira linha do desafio. Eu tinha como certo que "de qualquer tamanho" era um requisito definido - e Neil aparentemente também.

— Arnauld

@ Shaggy Apenas para esclarecer a todos: sua abordagem funciona até 0x1fffffffffffff- aka Number.MAX_SAFE_INTEGER- e retorna resultados arredondados além disso. Por sorte, os dois grandes casos de teste são arredondados corretamente.

— Arnauld

Não sabia que o código de @ Shaggy funcionava por acidente; Acho que deveria ter contado a distância entre o primeiro e o último 1bits no resultado. A propósito, você precisa $do primeiro regexp?

— Neil

@ Neil Eu não acho que posso me livrar disso $. A idéia é obter o zero final, se não houver 1resultado no resultado.

— Arnauld

0

REXX, 45 bytes

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

— idrougge
fonte

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*

(observe a nova linha à direita)

Experimente online!

Aqui está uma solução alternativa ao custo de 7 bytes: Experimente!

— user41805
fonte

Ligeiramente golfe . Abordagem alternativa .

— Neil

0

perl, 25

(código 24 + 1 sinalizador -n)

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

— Toto
fonte

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 snippet

Não limitado a 53 bits de precisão. Editar: salvei 5 bytes reescrevendo minha conversão de dígito, o que também reduz meus requisitos de idioma para ES6.

— Neil
fonte

Você pode reduzir o comprimento em 13 bytes, avaliando cada caractere como o valor hexadecimal. Experimente on-line

— fəˈnɛtɪk

@ fəˈnɛtɪk Isso não resolve a questão como colocada.

— 194 Neil

Aqui, removi os zeros à esquerda da primeira conversão. Experimente on-line ainda 2 bytes a menos.

— fənɛtɪk

@ fəˈnɛtɪk Combinei com a resposta de Arnauld e reduzi para 103: Experimente online!

— 194 Neil

@ fəˈnɛtɪk Espere, isso não funciona para o quinto caso de teste 0x00101011, desculpe.

— 194 Neil

0

Código de máquina 8086 - 63 bytes

Funciona para qualquer entrada até 125 caracteres (o comprimento máximo da linha de comando no 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 bytes

(Não concorrente, pois não lida com entradas de qualquer tamanho; eu tive sorte com as entradas de amostra)

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 snippet

— Shaggy
fonte

0

CJam , 24 bytes

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

Experimente online!

Explicação

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 negócios
fonte

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 snippet

— Tomas Langkaas
fonte

0

Perl 6 , 35 bytes

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

— Sean
fonte

0

Javascript, 63 bytes

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

— Steve Bennett
fonte

Hexadecimal para Binário

Pitão, 15 bytes

Python 2, 67 62 60 59 bytes

05AB1E , 11 bytes

Lote, 402 bytes

PHP, 66 65 63 bytes

JavaScript (ES6), 109 108 bytes

Casos de teste

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