เลขฐานสิบหกเป็น Binary


10

แปลงเลขฐานสิบหก (ทุกขนาด) เป็นเลขฐานสอง

ป้อนข้อมูลบวกเลขฐานสิบหกด้วยในการเริ่มต้น การป้อนข้อมูลที่ถูกต้องมักจะตรงกับ regex ต่อไปนี้: ถ้าใส่ไม่ได้เลขฐานสิบหกที่ถูกต้องนั่นคือสิ่งที่ไม่ตรงกับ regex นี้การส่งออกที่ควรจะเป็น
0x0x[0-9a-fA-F]+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

7
เมื่อคุณพูดว่า "ถ้าอินพุตไม่ใช่เลขฐานสิบหกที่ถูกต้อง" สิ่งประเภทใดที่สามารถเป็นได้ ตัวเลขในฐานที่แตกต่างกันอย่างไร วัตถุที่ไม่ใช่ตัวเลขใช่ไหม วัตถุบางอย่างที่ทำเพื่อโปรแกรมที่ผิดพลาดได้รับการประเมินแล้ว จริง ๆ แล้วฉันจะแนะนำให้หลีกเลี่ยงการตรวจสอบอินพุตเลย มันให้ความรู้สึกเหมือนเป็นความท้าทายกิ้งก่า
xnor

2
การอนุมานกฎจากกรณีทดสอบไม่เป็นไปได้และมีแนวโน้มว่าจะมีการปิดการท้าทายเนื่องจากไม่ชัดเจน นอกจากนั้นตัวอย่างก็ไม่ชัดเจนสำหรับฉัน "# 0ac4" ทำให้ดูเหมือนว่าสามารถรวมอักขระพิเศษใด ๆ ได้
xnor

1
ฉันยังไม่ชัดเจนหลังจากแก้ไขสิ่งที่เป็นไปได้ คือ#0ac4ยังคงเป็นกรณีทดสอบที่ถูกต้อง?
xnor

5
testcase ที่สองของคุณไม่ตรงกับ regex ของคุณ ( Xตัวพิมพ์ใหญ่)
Dada

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


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

0XFFไม่ได้ทำงานกับกรณีทดสอบ
Okx

@Okx: ทั้ง regex และส่วนอินพุตของคำถามระบุว่าการป้อนข้อมูลที่ถูกต้องเริ่มต้นด้วย0xดังนั้นฉันจะบอกว่ากรณีทดสอบเฉพาะไม่ถูกต้อง
Emigna

1
ใช่ฉันไม่ได้สังเกตว่า
Okx

9 ไบต์โดยใช้ใหม่Å?หรือ10 ไบต์โดยยังคงใช้ระบบเดิม
Kevin Cruijssen

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 ซึ่งจะลบ 0s นำหน้า อย่างไรก็ตามสิ่งนี้ล้มเหลวสำหรับอินพุตเช่น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));

echo stristr($a=$argn,"0X")==$a?decbin(hexdec(ltrim($a,Xx0))):0;นี่เป็นทางเลือกที่ดีหรือไม่? มันควรจะทำงานกับ testcases ที่ให้มา
JörgHülsermann

@ JörgHülsermann: ยิงฟันทางเลือกที่ดีและ it's ทำงานทั้งหมดได้รับกรณีทดสอบ แต่มันก็ไม่ได้ตรวจสอบค่าฐานสิบหกสำหรับความถูกต้อง (ดูความคิดเห็นของฉันในhexdecและbase_convert)
ติตัส

ฉันรู้และฉันคิดว่าคำถามนี้เป็นเรื่องตลกที่มีการทดสอบ
JörgHülsermann

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

-2 ไบต์<?=istead ของecho ที่มีตัวเลือก -F
JörgHülsermann

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]

กรณีทดสอบ


อืม ... นักกอล์ฟที่มีประสบการณ์ 2 คนกำลังส่งมอบโซลูชั่น JS มากกว่าสองเท่าตราบใดที่ฉันยังสงสัยว่าฉันพลาดอะไรบางอย่างในความท้าทายหรือไม่
ขนปุย

@Shaggy ทุกอย่างขึ้นอยู่กับการตีความบรรทัดแรกของการท้าทาย ฉันยอมรับว่าขนาดใดก็ได้เป็นข้อกำหนดที่แน่นอน - และนีลก็เห็นได้ชัดเช่นกัน
Arnauld

@Shaggy เพียงชี้แจงให้ทุกคนทราบ: แนวทางของคุณใช้ได้ผลมากถึง0x1fffffffffffff- aka Number.MAX_SAFE_INTEGER- และให้ผลลัพธ์ที่โค้งมนมากกว่านั้น โชคดีที่กรณีทดสอบขนาดใหญ่สองกรณีถูกปัดเศษอย่างถูกต้อง
Arnauld

อืมฉันไม่ทราบว่ารหัสของ @ Shaggy ทำงานโดยไม่ได้ตั้งใจ ฉันเดาว่าฉันควรนับระยะห่างระหว่าง1บิตแรกและบิตสุดท้ายในผลลัพธ์ โดยวิธีการที่คุณต้องการ$ใน regexp แรกหรือไม่
Neil

@ ไม่มีฉันไม่คิดว่าฉันสามารถกำจัดสิ่งนี้$ได้ ความคิดคือการได้ศูนย์สุดท้ายถ้าไม่มี1ผลลัพธ์เลย
Arnauld


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 ไบต์: ลองใช้!


แข็งแรงเล่นกอล์ฟออกไปเล็กน้อย วิธีทางเลือก
Neil


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 นั่นไม่ได้แก้คำถามตามที่วาง
Neil

ที่นี่ฉันลบศูนย์นำออกจากการแปลงครั้งแรกลองใช้ออนไลน์ยังสั้นกว่า 2 ไบต์
fəˈnɛtɪk

@ fəˈnɛtɪk ฉันรวมมันกับคำตอบของ Arnauld และทำให้มันเป็น 103: ลองออนไลน์!
Neil

@ fəˈnɛtɪk เดี๋ยวก่อนที่ใช้ไม่ได้กับกรณีทดสอบที่ห้า0x00101011ขออภัย
Neil

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

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.



โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.