10

Konvertieren Sie eine Hexadezimalzahl (beliebiger Größe) in eine Binärzahl.

Eingang
A POSITIVE Hexadezimalzahl mit einem 0xam Anfang. Eine gültige Eingabe entspricht immer dem folgenden regulären Ausdruck : 0x[0-9a-fA-F]+. Wenn die Eingabe keine gültige Hexadezimalzahl ist, dh alles, was nicht mit diesem regulären Ausdruck übereinstimmt, sollte die Ausgabe sein 0.

Ausgabe
Das in Binär konvertierte Hexadezimal.

Gewinnen der
Original Code-Golf Regeln, geringste Anzahl von Bissen (bytes).

Beispiele

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
quelle

7

Wenn Sie sagen "Wenn die Eingabe keine gültige Hexadezimalzahl ist", welche Art von Dingen kann es sein? Eine Nummer in einer anderen Basis? Ein nicht numerisches Objekt? Ein Objekt, das zum Absturz des Programms gemacht wurde, wird ausgewertet, möglicherweise auf nicht fangbare Weise? Wirklich, ich hätte vorgeschlagen, die Eingabevalidierung überhaupt zu vermeiden. Es fühlt sich an wie eine Chamäleon-Herausforderung .

— xnor

2

Das Ableiten von Regeln aus Testfällen ist nicht in Ordnung und wird die Herausforderung wahrscheinlich als unklar abschließen . Außerdem sind mir die Beispiele nicht klar. "# 0ac4" lässt den Eindruck entstehen, dass zusätzliche Zeichen enthalten sein können.

— xnor

1

Nach der Bearbeitung ist mir immer noch nicht klar, welche Eingaben möglich sind. Ist #0ac4noch ein gültiger Testfall?

— xnor

5

Ihr zweiter Testfall stimmt nicht mit Ihrem regulären Ausdruck überein ( XGroßbuchstaben).

— Dada

1

Müssen wir uns um führende Nullen kümmern? Können wir so etwas wie00011010

— user41805

3

Pyth, 15 Bytes

.B&qr0<z2"0x"vz

Erläuterung:

             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

Testsuite

Mit einer Regelklärung (die 0xin Kleinbuchstaben geschrieben sein muss) im OP können Sie r0für 13 Bytes entfernen .

.B&q<z2"0x"vz

— Steven H.
quelle

7

Python 2, 67 62 60 59 Bytes

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

Probieren Sie es online aus!

Version, die bei ungültiger Eingabe Fehler verursacht (27 Byte):

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

Probieren Sie es online aus!

— Mathe-Junkie
quelle

2

05AB1E , 11 Bytes

Î2£„0xQi¹Hb

Probieren Sie es online aus!

Erläuterung

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

Funktioniert nicht mit dem Testfall 0XFF.

— Okx

@Okx: Sowohl der reguläre Ausdruck als auch der Eingabeabschnitt der Frage geben an, dass die korrekte Eingabe mit beginnt. 0xIch würde also sagen, dass ein bestimmter Testfall falsch ist.

— Emigna

1

Ah ja, das habe ich nicht bemerkt.

— Okx

9 Bytes unter Verwendung des neuenÅ? oder 10 Bytes unter Verwendung des Legacy .

— Kevin Cruijssen

1

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

Nimmt Eingaben auf STDIN vor. 8 Zeilen werden dann meistens für die Eingabevalidierung verschwendet, daher sind die interessanten Zeilen Zeile 11, die jede hexadezimale Ziffer durch ihre binäre Entsprechung ersetzt, jedoch aufgrund von Stapelbeschränkungen durch eine führende .Zeile 12, die alle .s löscht , und Zeile 14 , wodurch führende Nullen entfernt werden. Dies schlägt jedoch für Eingaben wie fehl, 0x0so dass ich diejenigen "ungültig mache", was bedeutet, dass stattdessen 0 ausgegeben wird.

— Neil
quelle

1

PHP, 66 65 63 Bytes

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

laufen als Rohr mit -F.

Ohne das 0xwäre das schlimmste Problem, dass beide hexdecund base_converteinfach Zeichen ignorieren, die nicht hexadezimal sind; aber damit muss es trotzdem eine explizite Gültigkeitsprüfung geben.

45 Bytes ohne 0x:

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

— Titus
quelle

echo stristr($a=$argn,"0X")==$a?decbin(hexdec(ltrim($a,Xx0))):0;Ist das eine schöne Alternative? Es sollte für die gegebenen Testfälle funktionieren

— Jörg

@ JörgHülsermann: schöne Alternative It'sa, und es ist für alle Arbeits gegebenen Testfälle, aber es hat nicht den Hex - Wert für die Gültigkeit (auf siehe meinen Kommentar zu überprüfen hexdecund base_convert).

— Titus

Ich weiß und ich denke, die Frage ist ein Witz mit den gegebenen Testfällen.

— Jörg Hülsermann

1

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

— Christoph

-2 Bytes <?=anstelle von echo -F Option

— Jörg Hülsermann

0

JavaScript (ES6), 109 108 Byte

Funktioniert für jede Eingabegröße.

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

Testfälle

Code-Snippet anzeigen

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

Erweitern Sie das Snippet

— Arnauld
quelle

Hmm ... 2 erfahrene Golfer Absenden JS - Lösungen mehr als doppelt so lang wie mein hat mich gefragt , ob ich etwas in der Herausforderung verpasst haben.

— Shaggy

@ Shaggy Alles hängt von der Interpretation der ersten Zeile der Herausforderung ab. Ich hielt es für selbstverständlich, dass "jeder Größe" eine bestimmte Voraussetzung war - und Neil anscheinend auch.

— Arnauld

@Shaggy Nur um es für alle zu verdeutlichen: Ihr Ansatz funktioniert bis zu 0x1fffffffffffff- aka Number.MAX_SAFE_INTEGER- und liefert darüber hinaus gerundete Ergebnisse. Zum Glück sind die beiden großen Testfälle richtig gerundet.

— Arnauld

Huh, ich wusste nicht, dass @ Shaggys Code zufällig funktioniert hat. Ich denke, ich hätte den Abstand zwischen dem ersten und dem letzten 1Bit im Ergebnis zählen sollen. $Benötigen Sie übrigens die im ersten regulären Ausdruck?

— Neil

@Neil Ich glaube nicht, dass ich das loswerden kann $. Die Idee ist, die endgültige Null zu erhalten, wenn 1das Ergebnis überhaupt keine enthält .

— Arnauld

0

REXX, 45 Bytes

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

— Idrougge
quelle

0

Netzhaut , 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*

(Beachten Sie die nachfolgende Newline)

Probieren Sie es online aus!

Hier ist eine alternative Lösung zum Preis von 7 Bytes: Probieren Sie es aus!

— user41805
quelle

Leicht Golf gespielt . Alternativer Ansatz .

— Neil

0

Perl, 25

(Code 24 + 1 Flag -n)

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

— Toto
quelle

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

Erweitern Sie das Snippet

Nicht auf 53 Bit Genauigkeit beschränkt. Bearbeiten: Durch das Umschreiben meiner Ziffernkonvertierung wurden 5 Bytes gespeichert, wodurch sich auch meine Sprachanforderungen auf ES6 reduzieren.

— Neil
quelle

Sie können die Länge um 13 Byte reduzieren, indem Sie jedes Zeichen als Hex-Wert auswerten. Probieren Sie es online aus

— fəˈnɛtɪk

@ fəˈnɛtɪk Das löst die gestellte Frage nicht.

— Neil

Hier habe ich führende Nullen aus der ersten Konvertierung entfernt. Try it Online noch 2 Bytes kürzer.

— fəˈnɛtɪk

@ fəˈnɛtɪk Ich habe es mit Arnauld's Antwort kombiniert und es auf 103 gebracht: Probieren Sie es online aus!

— Neil

@ fəˈnɛtɪk Warte, das funktioniert beim fünften Testfall nicht 0x00101011, sorry.

— Neil

0

8086 Maschinencode - 63 Bytes

Funktioniert für alle Eingaben mit bis zu 125 Zeichen (die maximale Befehlszeilenlänge unter 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
quelle

0

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

(Nicht konkurrierend, da es keine Eingaben jeglicher Größe verarbeitet; ich hatte gerade Glück mit den Beispieleingaben)

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

Erweitern Sie das Snippet

— Zottelig
quelle

0

CJam , 24 Bytes

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

Probieren Sie es online aus!

Erläuterung

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.

— Geschäftskat
quelle

0

JavaScript (ES6), 107 Zeichen

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

Erweitern Sie das Snippet

— Tomas Langkaas
quelle

0

Perl 6 , 35 Bytes

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

— Sean
quelle

0

Javascript, 63 Bytes

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

— Steve Bennett
quelle

Hexadezimal bis binär

Pyth, 15 Bytes

Python 2, 67 62 60 59 Bytes

05AB1E , 11 Bytes

Stapel, 402 Bytes

PHP, 66 65 63 Bytes

JavaScript (ES6), 109 108 Byte

Testfälle

REXX, 45 Bytes

Netzhaut , 149 Bytes

Perl, 25

JavaScript (ES6), 116 111 Byte

8086 Maschinencode - 63 Bytes

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

CJam , 24 Bytes

JavaScript (ES6), 107 Zeichen

Perl 6 , 35 Bytes

Javascript, 63 Bytes