हेक्साडेसिमल को बाइनरी

Question

एक हेक्साडेसिमल संख्या (किसी भी आकार का) को एक बाइनरी संख्या में परिवर्तित करें।

शुरुआत में एक के साथ
एक पॉज़िटिव हेक्साडेसिमल इनपुट0x । एक वैध इनपुट हमेशा निम्न रेगुलर एक्सप्रेशन से मेल होगा: 0x[0-9a-fA-F]+। इनपुट है नहीं एक वैध हेक्साडेसिमल संख्या, कि है, कुछ भी इस regex मिलान नहीं, उत्पादन होना चाहिए 0।

आउटपुट
हेक्साडेसिमल बाइनरी में परिवर्तित हो गया।

मूल कोड-गोल्फ नियम जीतना , काटने की न्यूनतम मात्रा (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

Comments

जब आप कहते हैं कि "यदि इनपुट वैध हेक्साडेसिमल संख्या नहीं है", तो यह किस प्रकार की हो सकती है? एक अलग आधार में एक संख्या? एक गैर-संख्यात्मक वस्तु? कार्यक्रम को क्रैश करने के लिए बनाई गई कुछ वस्तु का मूल्यांकन किया जाता है, संभवत: एक गैर-बिल्ली के समान तरीके से? वास्तव में, मैंने सुझाव दिया था कि इनपुट सत्यापन से बचना चाहिए; यह एक गिरगिट चुनौती की तरह लगता है ।

— xnor

परीक्षण मामलों से नियमों का हवाला देना ठीक नहीं है और संभावना है कि चुनौती बंद हो जाएगी। इसके अलावा, उदाहरण मेरे लिए स्पष्ट नहीं हैं। "# 0ac4" से ऐसा लगता है कि किसी भी अतिरिक्त चरित्र को शामिल किया जा सकता है।

— xnor

मैं अभी भी स्पष्ट नहीं हूँ कि संपादन क्या इनपुट संभव है। क्या #0ac4अभी भी एक वैध परीक्षण मामला है?

— xnor

आपका दूसरा टेस्टकेस आपके रेगेक्स ( Xअपरकेस) से मेल नहीं खाता है।

— दादा

क्या हमें अग्रणी जीरो की देखभाल करने की आवश्यकता है? क्या हम कुछ उत्पादन कर सकते हैं जैसे00011010

— user41805

Answer 1

अजगर, 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ओपी में एक नियम स्पष्टीकरण (जिसे कम होना चाहिए) के साथ, आप r013 बाइट्स के लिए निकाल सकते हैं ।

.B&q<z2"0x"vz

Answer 2

पायथन 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:]

इसे ऑनलाइन आज़माएं!

Answer 3

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

Comments

परीक्षण मामले के साथ काम नहीं करता है 0XFF।

— ओकेक्स

@ ओएक्सएक्स: प्रश्न के इनपुट और इनपुट खंड दोनों में कहा गया है कि सही इनपुट शुरू होता है 0xइसलिए मैं कहूंगा कि विशिष्ट परीक्षण-मामला गलत है।

— एमिग्ना

आह, मैं उस पर ध्यान नहीं दिया।

— ओकेक्स

9 बाइट्स नएÅ? या 10 बाइट्स का उपयोग करके अभी भी विरासत का उपयोग करके ।

— केविन क्रूज़सेन

Answer 4

बैच, 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 है।

Answer 5

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

Comments

echo stristr($a=$argn,"0X")==$a?decbin(hexdec(ltrim($a,Xx0))):0;क्या यह एक अच्छा विकल्प है? यह दिए गए

— टेस्टेसिस के

@ JörgHülsermann: यह एक अच्छा विकल्प है, और यह सभी दिए गए परीक्षण मामलों के लिए काम कर रहा है , लेकिन यह वैधता के लिए हेक्स मान की जांच नहीं करता है (मेरी टिप्पणी देखें hexdecऔर base_convert)।

— टाइटस

मुझे पता है और मुझे लगता है कि प्रश्न दिए गए टेस्टकेस के साथ एक मजाक है।

— जार्ज ह्यूल्समैन

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

— क्रिस्टोफ

-2 बाइट्स <?=के istead echo एफ विकल्प के साथ

— Jörg Hülsermann

Answer 6

जावास्क्रिप्ट (ईएस 6), 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

Comments

हम्म ... 2 अनुभवी गोल्फर जे एस समाधान प्रस्तुत करने के दो बार के रूप में अधिक से अधिक मेरा मुझे सोच अगर मैं चुनौती में कुछ छूट गया है है।

— झबरा

@ शैगी यह सब चुनौती की पहली पंक्ति की व्याख्या पर निर्भर करता है। मैंने इसे इस बात के लिए लिया कि 'किसी भी आकार' की निश्चित आवश्यकता थी - और इसी तरह नील ने स्पष्ट रूप से किया।

— अरनौलड

@ शैगी बस सभी के लिए स्पष्ट करने के लिए: आपका दृष्टिकोण 0x1fffffffffffff- उर्फ ​​के लिए काम करता है Number.MAX_SAFE_INTEGER- और उससे परे गोल परिणाम देता है। भाग्य से, दो बड़े परीक्षण मामलों को सही ढंग से गोल किया जाता है।

— अरनुलद

हुह, मुझे एहसास नहीं था कि @ झबरा का कोड दुर्घटना से काम करता है; मुझे लगता है कि मुझे 1परिणाम में पहले और अंतिम बिट्स के बीच की दूरी को गिनना चाहिए था । वैसे, क्या आपको $पहले रेगेक्सपी की आवश्यकता है?

— नील

@ मुझे नहीं लगता कि मैं इससे छुटकारा पा सकता हूं $। यदि 1परिणाम में कुछ भी नहीं है तो विचार अंतिम शून्य प्राप्त करना है ।

— अरनौलद

Answer 7

REXX, 45 बाइट्स

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

Answer 8

रेटिना , 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 बाइट्स की कीमत पर एक वैकल्पिक समाधान है: इसे आज़माएं!

Comments

थोड़ा गोल्फ । वैकल्पिक दृष्टिकोण ।

— नील

Answer 9

पर्ल, २५

(कोड 24 + 1 ध्वज-एन)

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

Answer 10

जावास्क्रिप्ट (ईएस 6), 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 में मेरी भाषा आवश्यकताओं को भी कम करता है।

Comments

आप प्रत्येक वर्ण का मूल्यांकन हेक्स मान के अनुसार 13 बाइट्स द्वारा लंबाई कम कर सकते हैं। इसे ऑनलाइन आज़माएं

— f itnɛtɪk

@ f @n astɪk जो प्रश्न को हल नहीं करता है।

— नील

यहां, मैंने पहले रूपांतरण से अग्रणी शून्य हटा दिया है इसे ऑनलाइन आज़माएं अभी भी 2 बाइट्स छोटे हैं।

— f --n 16tɪk 16

@ f @nnatɪk मैंने इसे अर्नुलद के उत्तर के साथ जोड़ दिया और इसे 103 तक नीचे कर दिया: इसे ऑनलाइन आज़माएं!

— नील

@ f @n fortɪk रुको, कि पांचवें परीक्षण मामले के लिए काम नहीं करता है 0x00101011, क्षमा करें।

— नील

Answer 11

8086 मशीन कोड - 63 बाइट्स

125 वर्णों तक किसी भी इनपुट के लिए काम करता है (डॉस में अधिकतम कमांड लाइन लंबाई)

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

Answer 12

जावास्क्रिप्ट (ईएस 6), 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`);

Answer 13

सीजेएम , 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.

Answer 14

जावास्क्रिप्ट (ईएस 6), 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'))

Answer 15

पर्ल 6 , 35 बाइट्स

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

Answer 16

जावास्क्रिप्ट, 63 बाइट्स

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