การมองหาค่าไบนารีที่พิมพ์เป็นวงรีและแท่งไม่ใช่เรื่องง่าย ... เพื่อช่วยในการนั้นคุณต้องเขียนฟังก์ชั่น (หรือโปรแกรม) ที่พิมพ์ตัวเลขในรูปแบบไบนารีที่กำหนดเอง
ดังนั้นฉันต้องการใช้ตัวเลขพูด 3 ( 00000011) และเอาท์พุทบิตในรูปแบบที่ผู้ใช้กำหนดเช่นกับคู่ที่คั่นด้วยช่องว่าง:

00 00 00 11

หรือพูดในลำดับที่กลับกันและมีผู้ตกแต่งบางอย่างเช่น:

11_00_00_00

นอกจากนี้จะต้องมีความเป็นไปได้ที่จะแสดง '0' และ '1' เป็นอักขระที่กำหนดเองเพื่อแยกความแตกต่างได้ดีขึ้นเช่น:

XX oo oo oo

ดังนั้นความท้าทายคือการเขียนโค้ดที่ทำทุกอย่างตามข้อกำหนดต่อไปนี้

สเปค

ฟังก์ชั่นรับอินพุตดังนี้: f (A, mask, ศูนย์, อัน)

พารามิเตอร์:

เอ - จำนวนอินพุต - จำนวนเต็มใด ๆ (ไม่ได้ลงนาม) ในช่วง 0-255
mask - พารามิเตอร์สตริงที่กำหนดการสร้างเอาต์พุต
ศูนย์ - สตริงที่มีความยาวเท่ากันกำหนด glyphs 'ศูนย์' สำหรับแต่ละช่องเอาต์พุต
ตัว - สตริงที่มีความยาวเท่ากันกำหนดสัญลักษณ์หนึ่งอันสำหรับแต่ละช่องออก

กฎสำหรับการสร้างผลผลิต:

ดูภาพนี้พร้อมกับตัวอย่างอย่างใกล้ชิดเพื่อทำความเข้าใจวิธีสร้างผลลัพธ์:

ดังนั้นเพียงหลักเดียวในหน้ากากมีการแยกวิเคราะห์และถูกแทนที่ด้วยบิตของที่สอดคล้องกันตัวละครอื่น ๆ จะถูกทิ้งไว้ตามที่เป็นอยู่ เพิ่มเติมถ้าค่าของบิตที่นำมาเป็น 1 ก็จะปรากฏขึ้นในผลลัพธ์สุดท้ายเป็น "X" และถ้าเป็น 0 ก็จะปรากฏขึ้นเป็น "o" ในตัวอย่างข้างต้นบิตที่ถ่ายสี่บิตคือ "1" ดังนั้นเราจะเห็น "X" ในทุกช่อง

ถ้าจำนวนการป้อนข้อมูลที่เป็น 128 X foo bar oooแล้วเหตุผลการส่งออกจะเป็น อักขระในพารามิเตอร์ "ศูนย์" และ "คน": ตัวอักษร ASCII ที่พิมพ์ได้ใด ๆ ถือว่าพวกเขาอยู่ในแนวเดียวกันกับหน้ากาก

หมายเหตุ :

• บิตถูกทำดัชนี 0: บิตที่ 0 คือ MSB
• สมมติว่าตัวเลข 8,9 ไม่ได้รับอนุญาตในสตริงมาสก์
• อินพุตสตริงรวมถึงอักขระ ASCII ที่พิมพ์ได้
• 'ศูนย์' และ 'รายการ' ถูกจัดชิดกับหน้ากาก
• สำหรับอักขระพิเศษ / โมดิฟายเออร์ในภาษาของคุณ: เราสามารถสันนิษฐานได้ว่าพวกเขาจะไม่ปรากฏในสตริงอินพุต

สำหรับความคมชัดดูตัวอย่างเพิ่มเติม

อินพุต -> ตัวอย่างเอาต์พุต

เอาท์พุททั้งหมด 8 บิตในการสั่งซื้อร่วมกันด้วยตัวคั่นช่องว่างในสัญกรณ์วงรีและติดที่พบบ่อย:

mask  =  "0123 4567"  
zeros =  "0000 0000"  
ones  =  "1111 1111"  

A=1 ->    0000 0001

เอาท์พุทในลำดับที่ย้อนกลับในสัญกรณ์ dash-and-glyph:

mask =    "| 7654 3210 |"
zeros=    "  ---- ----  "
ones =    "  ssss ssss  "

A=1  ->    | s--- ---- |
A=3   ->   | ss-- ---- |
A=128->    | ---- ---s |

สัญกรณ์ที่หลากหลายในหนึ่งเอาต์พุตเช่นสำหรับข้อมูลที่บรรจุ:

mask =       "0 | 123 4567"
zeros=       "    --- ----"
ones =       "X   kkk ssss"

A= 15  ->       | --- ssss
A= 16  ->       | --k ----
A= 32  ->       | -k- ----
A= 128 ->     X | --- ----
A= 255 ->     X | kkk ssss

รูปแบบการทำซ้ำ:

mask =    "| 7 66 555 4444 |"
zeros=    "  . .. ... ....  "
ones =    "  0 00 000 0000  "

A= 0 ->    | . .. ... .... |
A= 1 ->    | 0 .. ... .... |
A= 2 ->    | . 00 ... .... |
A= 3 ->    | 0 00 ... .... |
A= 4 ->    | . .. 000 .... |

ปรับปรุง

กฎได้ง่ายขึ้นเล็กน้อย - โปรแกรมจะต้องพิมพ์หมายเลขหนึ่งเท่านั้น (ไม่ใช่อาร์เรย์ / รายการหมายเลขตามที่เสนอในตอนแรก)

JavaScript (ES6), 57 ไบต์

(A,M,O,I)=>M.replace(/[\d]/g,(d,i)=>(A>>7-d)%2?I[i]:O[i])

f=
(A,M,O,I)=>M.replace(/[\d]/g,(d,i)=>(A>>7-d)%2?I[i]:O[i])

console.log( f(1, "0123 4567", "0000 0000", "1111 1111") )
console.log( f(3, "| 7654 3210 |", "  ---- ----  ", " ssss ssss ") )
console.log( f(4, "| 7 66 555 4444 |", "  . .. ... ....  ", "  0 00 000 0000  ") )

ทับทิมขนาด 48 ไบต์

->a,f,*b{f.gsub(/\d/){b[a[55-$&.ord]][$`.size]}}

zeroes และคนพารามิเตอร์จะถือว่าเป็นอาร์เรย์ ( *b) และศูนย์พารามิเตอร์ถูกเก็บไว้ในและคนที่เก็บไว้ในพารามิเตอร์b[0]b[1]

พารามิเตอร์ mask fมีการ/\d/แทนที่แต่ละตัว ( ) ด้วยอักขระจากอาร์เรย์ที่เหมาะสม ตัวแปรพิเศษ$`ซึ่งเก็บข้อความที่นำไปสู่การแข่งขันปัจจุบันคือ (ab) ที่ใช้ที่นี่เพื่อติดตามตำแหน่ง

การทำดัชนีบิตของรูบี้เรียก 0 บิตที่มีนัยสำคัญน้อยที่สุด แต่ความท้าทายเรียก 0 บิตที่สำคัญที่สุด การลบ ASCII จาก 55 (ตัวอักษร '7') ให้ผลเป็นดัชนีรูบี้บิตที่ใช้งานได้

ลองออนไลน์!

Perl 6 , 60 ไบต์

->\a,$_,\o,\z{S:g|\d|{substr (z,o)[a+>(7-$/)%2],$/.from,1}|}

Python ขนาด 97 ไบต์

lambda A,M,Z,O:"".join([[Z,O][1&(A>>7-int(d))][i] if d.isdigit() else d for i,d in enumerate(M)])

Mathematica, 131 ไบต์

""<>Table[(f/@{##2})[[x[[i]],i]],{i,Length[x=(f=Characters)@#2/.Table[ToString@i->2+Floor[#/2^(7-i)]~Mod~2,{i,0,7}]/._String->1]}]&

q / kdb +, 86 64 ไบต์

สารละลาย:

f:{[A;M;Z;O]@[M;m;:;((-8#0b vs A)"I"$'M m)(Z;O)'m:(&)M in .Q.n]}

ตัวอย่าง:

q)f[1;"0123 4567";"0000 0000";"1111 1111"]
"0000 0001"
q)f[1;"| 7654 3210 |";"  ---- ----  ";"  ssss ssss  "]
"| s--- ---- |"
q)f[15;"0 | 123 4567";"    --- ----";"X   kkk ssss"]
"  | --- ssss"
q)f [0;"| 7 66 555 4444 |";"  . .. ... ....  ";"  0 00 000 0000  "]
"| . .. ... .... |"

คำอธิบาย:

ดึงดัชนีออกมาซึ่งรูปแบบการป้อนข้อมูลMเป็นตัวเลขเรียกว่าmนี่คือที่ที่เราจะทำการปรับเปลี่ยนรูปแบบการป้อนข้อมูล นำตัวเลขออกจากสตริงส่งไปยังจำนวนเต็มจากนั้นทำดัชนีลงในอาร์เรย์ 8 บิตของเราเพื่อรับการสั่งซื้อที่ถูกต้อง การใช้งานนี้อาร์เรย์ 8 บิตเพื่อดัชนีลงอย่างใดอย่างหนึ่งO(ถ้าเป็นชุด 1) หรือZ(ถ้า 0 เป็นชุด) mแล้วดัชนีลงในรายชื่อเหล่านี้ที่ดัชนีที่กำหนดโดย สุดท้ายใช้ ( :) mรายการใหม่นี้เพื่อหน้ากากเดิมที่ดัชนี

{[A;M;Z;O]                                                   } / lambda function with 4 parameters
          @[ ; ; ;                                          ]  / apply, applies 3rd parameter to 1st parameter at indexes from parameter 2 with parameter 4 :)
                   (-8#0b vs A)                                / convert input number to binary (64 bit), take the last 8 items
                                              m:(&)M in .Q.n   / returns indices where mask is in "0123..789", stores in variable m
                               "I"$'M m                        / index into mask at indices m, then cast these numbers to an integer array
                  (                    )                       / we then index into our 8 bits a these offsets to get the output order
                                        (Z;O)                  / 2-item list of the zeroes and ones mask
                                             '                 / take each item on the left and right and apply them to (Z;O) (ie index in at 0 / 1 and then 123..67)
            M m :                                              / apply *this* list to M at each index given by m

หมายเหตุ:

สามารถตัดออกไปอีก 14 ไบต์ถ้าเราได้รับอนุญาตให้อาร์กิวเมนต์ในรูปแบบ:

[A;M;(Z;O)]

ตามที่ q อนุญาตให้มีได้สูงสุด 3 อาร์กิวเมนต์ที่กำหนดให้กับฟังก์ชันโดยไม่มีการตั้งชื่ออย่างชัดเจน (ทั้งxคู่yและzตามลำดับ):

f:{@[y;m;:;((-8#0b vs x)"I"$'y m)z'm:(&)y in .Q.n]}