10

Преобразовать шестнадцатеричное число (любого размера) в двоичное число.

Входные ПОЗИТИВ шестнадцатеричное число с самого начала. Действительный вход всегда будет соответствовать следующему регулярному выражению: . Если входные данные не являются действительными шестнадцатеричными числами, то есть чем-либо, не соответствующим этому регулярному выражению, выходные данные должны быть .
0x0x[0-9a-fA-F]+0

Выходные данные
Шестнадцатеричный код, преобразованный в двоичный.

Выигрышные
правила Code-Golf, минимальное количество укусов (bytes).

Примеры

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

— Хашим Каяни
источник

7

Когда вы говорите «Если ввод не является действительным шестнадцатеричным числом», что это может быть за тип? Номер в другой базе? Нечисловой объект? Какой-то объект, созданный для аварийного завершения программы, оценивается, возможно, неуловимым способом? На самом деле, я бы предложил вообще избегать проверки входных данных; это похоже на вызов хамелеона .

— xnor

2

Выводить правила из тестовых случаев не в порядке и, скорее всего, вызов будет закрыт как неясный. Кроме того, примеры мне не понятны. «# 0ac4» создает впечатление, что могут быть включены любые дополнительные символы.

— xnor

1

Мне все еще не ясно после редактирования, какие входы возможны. Все #0ac4еще действительный контрольный пример?

— xnor

5

Ваш второй контрольный пример не соответствует вашему регулярному выражению ( Xэто верхний регистр).

— Дада

1

Нужно ли нам заботиться о ведущих нулях? Можем ли мы вывести что-то вроде00011010

— user41805

3

Pyth, 15 байт

.B&qr0<z2"0x"vz

Объяснение:

             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

Тестирование

С разъяснением правил (которое 0xдолжно быть в нижнем регистре) в OP вы можете удалить r013 байт.

.B&q<z2"0x"vz

— Стивен Х.
источник

7

Python 2, 67 62 60 59 байт

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

Попробуйте онлайн!

Версия с ошибками при неверном вводе (27 байт):

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

Попробуйте онлайн!

— математик наркоман
источник

2

05AB1E , 11 байт

Î2£„0xQi¹Hb

Попробуйте онлайн!

объяснение

Î             # 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
источник

Не работает с тестовым примером 0XFF.

— Okx

@Okx: и регулярное выражение, и раздел ввода в вопросе утверждают, что правильный ввод начинается с 0xтого, что я бы сказал, что конкретный контрольный пример неверен.

— Emigna

1

Ах да, я этого не заметил.

— Okx

9 байтов при использовании новогоÅ? или 10 байтов при использовании прежнего .

— Кевин Круйссен

1

Пакет, 402 байта

@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. 8 строк тогда в основном тратятся впустую при проверке входных данных, поэтому интересными являются строки 11, которые заменяют каждую шестнадцатеричную цифру двоичным эквивалентом, но из-за ограничений пакета, с ведущей .строкой 12, которая удаляет все .s, и строкой 14 , который удаляет ведущие 0. Однако для входных данных это не удается, 0x0поэтому я «аннулирую» те, что означает, что вместо этого выводится 0.

— Нил
источник

1

PHP, 66 65 63 байта

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

беги как труба с -F.

Без этого 0xнаихудшей проблемой будет то, что оба hexdecи base_convertпросто игнорируют символы, которые не являются шестнадцатеричными; но с этим, в любом случае должна быть явная проверка действительности.

45 байт без 0x:

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

— Titus
источник

echo stristr($a=$argn,"0X")==$a?decbin(hexdec(ltrim($a,Xx0))):0;Это хорошая альтернатива? Это должно работать для данных тестов

— Jörg Hülsermann

@ JörgHülsermann: Это хорошая альтернатива, и она работает для всех заданных тестовых случаев, но она не проверяет шестнадцатеричное значение на достоверность (см. Мой комментарий hexdecи base_convert).

— Тит

Я знаю и думаю, что вопрос - шутка с данными тестами.

— Йорг Хюльсерманн

1

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

— Кристоф

-2 байта <?=вместо echo опции -F

— Йорг Хюльсерманн

0

JavaScript (ES6), 109 108 байт

Работает для любого размера ввода.

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

Контрольные примеры

Показать фрагмент кода

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

Развернуть фрагмент

— Arnauld
источник

Хм ... 2 опытных игроков в гольф , подающие решения JS более чем в два раза до тех пор , как мина имеет мне интересно , если я что - то пропустил в вызов.

— Лохматый

@ Shaggy Все зависит от интерпретации первой строки задачи. Я считал само собой разумеющимся, что «любого размера» было определенным требованием - как и Нейл, очевидно.

— Арно

@ Shaggy Просто чтобы уточнить для всех: ваш подход работает до 0x1fffffffffffff- ака Number.MAX_SAFE_INTEGER- и возвращает округленные результаты за это. К счастью, два больших тестовых случая округлены правильно.

— Арно

Да, я не осознавал, что код @ Shaggy сработал случайно; Я думаю, я должен был посчитать расстояние между первым и последним 1битами в результате. Кстати, вам нужно $в первом регулярном выражении?

— Нил

@ Нил, я не думаю, что смогу избавиться от этого $. Идея состоит в том, чтобы получить конечный ноль, если его нет 1в результате.

— Арно

0

REXX, 45 байт

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

— idrougge
источник

0

Сетчатка , 149 байт

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

(обратите внимание на завершающий перевод строки)

Попробуйте онлайн!

Вот альтернативное решение стоимостью 7 байт: Попробуйте!

— user41805
источник

Слегка поиграл в гольф . Альтернативный подход .

— Нил

0

Perl, 25

(код 24 + 1 флаг -n)

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

— Toto
источник

0

JavaScript (ES6), 116 111 байт

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 битами точности. Изменить: 5 байтов сохранены, переписав мое преобразование цифр, что также снижает мои языковые требования до ES6.

— Нил
источник

Вы можете уменьшить длину на 13 байт, оценив каждый символ как шестнадцатеричное значение. Попробуйте онлайн

— fəˈnɛtɪk

@ fəˈnɛtɪk Это не решает вопрос, как изложено.

— Нил

Здесь я удалил начальные нули из первой конвертации. Попробуйте онлайн еще на 2 байта короче.

— fəˈnɛtɪk

@ fəˈnɛtɪk Я совместил это с ответом Арно и довел его до 103: Попробуйте онлайн!

— Нил

@ fəˈnɛtɪk Подождите, это не работает для пятого теста 0x00101011, извините.

— Нил

0

8086 машинный код - 63 байта

Работает для любого ввода до 125 символов (максимальная длина командной строки в 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
источник

0

JavaScript (ES6), 53 52 49 50 52 45 байт

(Неконкурентный, так как он не обрабатывает входные данные любого размера; мне просто повезло с входными примерами)

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

Развернуть фрагмент

— мохнатый
источник

0

CJam , 24 байта

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

Попробуйте онлайн!

объяснение

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.

— Бизнес Кот
источник

0

JavaScript (ES6), 107 символов

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

Развернуть фрагмент

— Томас Лангкаас
источник

0

Perl 6 , 35 байт

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

— Шон
источник

0

Javascript, 63 байта

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

— Стив Беннетт
источник

Шестнадцатеричный в двоичный

Pyth, 15 байт

Python 2, 67 62 60 59 байт

05AB1E , 11 байт

Пакет, 402 байта

PHP, 66 65 63 байта

JavaScript (ES6), 109 108 байт

Контрольные примеры

REXX, 45 байт

Сетчатка , 149 байт

Perl, 25

JavaScript (ES6), 116 111 байт

8086 машинный код - 63 байта

JavaScript (ES6), 53 52 49 50 52 45 байт

CJam , 24 байта

JavaScript (ES6), 107 символов

Perl 6 , 35 байт

Javascript, 63 байта