Đánh dấu các giá trị nhị phân được in dưới dạng hình bầu dục và gậy không quá dễ dàng ... Để giúp với điều đó, bạn phải viết một hàm (hoặc một chương trình) in các số trong biểu diễn nhị phân tùy chỉnh.
Vì vậy, tôi muốn lấy một số, giả sử 3 ( 00000011) và xuất các bit ở định dạng do người dùng xác định, ví dụ với các cặp được phân tách bằng dấu cách:

00 00 00 11

hoặc, giả sử, theo thứ tự đảo ngược và với một số trang trí, ví dụ:

11_00_00_00

Hơn nữa, phải có khả năng hiển thị '0' và '1' dưới dạng các ký tự tùy chỉnh để phân biệt chúng tốt hơn, ví dụ:

XX oo oo oo

Vì vậy, thách thức là viết mã mà tất cả các thông số kỹ thuật sau đây.

Sự chỉ rõ

Hàm nhận đầu vào như thế này: f (A, mặt nạ, số không, số)

Thông số:

A - số đầu vào - bất kỳ số nguyên (không dấu) nào trong phạm vi 0-255.
mask - một tham số chuỗi xác định cấu trúc của đầu ra.
số không - một chuỗi có cùng độ dài, xác định glyphs 'zero' cho mỗi vị trí đầu ra.
những cái - một chuỗi có cùng độ dài, xác định glyphs 'một' cho mỗi khe đầu ra.

Quy tắc xây dựng đầu ra:

Nhìn vào hình ảnh này với ví dụ chặt chẽ để hiểu cách tạo đầu ra:

Vì vậy, chỉ các chữ số duy nhất trong mặt nạ được phân tích cú pháp và được thay thế bằng các bit tương ứng của A, các ký tự khác được giữ nguyên . Hơn nữa, nếu giá trị của bit đã lấy là 1 thì nó hiển thị trong đầu ra cuối cùng là "X" và nếu là 0 thì nó hiển thị là "o". Trong ví dụ trên, tất cả bốn bit được lấy là "1" vì vậy chúng ta thấy "X" trong tất cả các vị trí.

Nếu số đầu vào là 128, thì theo logic, đầu ra sẽ là X foo bar ooo. Các ký tự trong tham số "số không" và "số": bất kỳ ký tự ASCII có thể in nào, giả sử chúng luôn được căn chỉnh với mặt nạ.

Ghi chú :

• Các bit được lập chỉ mục 0: bit thứ 0 là MSB.
• Giả sử rằng các chữ số 8,9 không được phép trong chuỗi mặt nạ.
• Chuỗi đầu vào bao gồm bất kỳ ký tự ASCII có thể in.
• 'Số không' và 'số' được căn chỉnh với mặt nạ.
• Đối với các ký tự / sửa đổi đặc biệt trong ngôn ngữ của bạn: chúng tôi có thể cho rằng chúng sẽ không xuất hiện trong chuỗi đầu vào.

Để rõ ràng, xem thêm ví dụ.

Đầu vào -> Ví dụ đầu ra

Xuất tất cả 8 bit theo thứ tự chung với một dấu phân cách không gian, theo ký hiệu hình bầu dục chung và hình que:

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

A=1 ->    0000 0001

Đầu ra theo thứ tự đảo ngược, theo ký hiệu gạch ngang và glyph:

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

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

Các ký hiệu đa dạng trong một đầu ra, ví dụ: đối với dữ liệu được đóng gói:

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

Lặp lại các mẫu:

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 .... |

Cập nhật

Các quy tắc đã được đơn giản hóa một chút - chương trình phải chỉ in một số (không phải mảng / danh sách các số như đã đề xuất ban đầu).

JavaScript (ES6), 57 byte

(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  ") )

Ruby , 48 byte

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

Các tham số số 0 và số 0 được coi là một mảng ( *b) và với tham số số không được lưu trong b[0]và tham số được lưu trong b[1].

Tham số mặt nạ fcó mỗi chữ số ( /\d/) được thay thế bằng một ký tự từ mảng thích hợp. Biến đặc biệt $`, giữ văn bản dẫn đến kết quả khớp hiện tại, là (ab) được sử dụng ở đây để theo dõi vị trí.

Lập chỉ mục bit của Ruby gọi 0 bit có trọng số thấp nhất, nhưng thách thức gọi 0 là bit quan trọng nhất. Phép trừ ASCII từ 55 (ký tự '7') mang lại chỉ số bit Ruby có thể sử dụng được.

Hãy thử trực tuyến!

Perl 6 , 60 byte

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

Python, 97 byte

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

Toán học, 131 byte

""<>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 byte

Giải pháp:

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

Ví dụ:

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  "]
"| . .. ... .... |"

Giải trình:

Kéo ra các chỉ số trong đó mặt nạ đầu vào Mlà một chữ số, gọi nó mlà đây là nơi chúng ta sẽ sửa đổi mặt nạ đầu vào. Lấy các chữ số ra khỏi chuỗi, chuyển sang số nguyên và sau đó lập chỉ mục vào mảng 8 bit của chúng tôi để có thứ tự chính xác. Sử dụng mảng 8 bit này để lập chỉ mục vào O(nếu 1 được đặt) hoặc Z(nếu 0 được đặt), sau đó lập chỉ mục vào các danh sách này tại các chỉ số được cung cấp bởi m. Cuối cùng áp dụng ( :) danh sách mới này vào mặt nạ ban đầu tại các chỉ số 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

Ghi chú:

Có thể tắt thêm 14 byte nếu chúng tôi được phép đưa ra các đối số ở dạng:

[A;M;(Z;O)]

như q cho phép lên đến 3 đối số được trao cho một chức năng mà không bị tên một cách rõ ràng (họ x, yvà ztương ứng):

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