Mengamati nilai-nilai biner yang dicetak sebagai oval dan tongkat tidaklah mudah ... Untuk membantu hal itu, Anda harus menulis fungsi (atau program) yang mencetak angka dalam representasi biner khusus.
Jadi saya ingin mengambil angka, katakan 3 ( 00000011) dan output bit dalam format yang ditentukan pengguna, misalnya dengan pasangan yang dipisahkan oleh ruang:

00 00 00 11

atau, katakanlah, dalam urutan terbalik dan dengan beberapa dekorator, misalnya:

11_00_00_00

Selain itu, harus ada kemungkinan untuk menunjukkan '0' dan '1' sebagai karakter khusus untuk membedakan mereka dengan lebih baik, misalnya:

XX oo oo oo

Jadi tantangannya adalah untuk menulis kode yang melakukan itu semua dalam spesifikasi berikut.

Spesifikasi

Fungsi mengambil input seperti ini: f (A, mask, nol, ones)

Parameter:

A - nomor input - bilangan bulat (tidak bertanda) apa pun dalam rentang 0-255.
mask - parameter string yang mendefinisikan konstruksi output.
nol - string dengan panjang yang sama, mendefinisikan mesin terbang 'nol' untuk setiap slot output.
yang - string dengan panjang yang sama, mendefinisikan mesin terbang 'satu' untuk setiap slot output.

Aturan untuk konstruksi output:

Lihatlah gambar ini dengan contoh cermat untuk memahami bagaimana output dihasilkan:

Jadi hanya satu digit dalam topeng yang diuraikan dan diganti dengan bit A yang sesuai, karakter lain dibiarkan apa adanya . Lebih lanjut, jika nilai bit yang diambil adalah 1 maka akan muncul di output akhir sebagai "X" dan jika itu 0 maka akan muncul sebagai "o". Dalam contoh di atas keempat bit yang diambil adalah "1" jadi kita melihat "X" di semua slot.

Jika nomor input adalah 128, maka, secara logis, outputnya adalah X foo bar ooo. Karakter dalam parameter "nol" dan "yang": karakter ASCII apa pun yang dapat dicetak, menganggap mereka selalu sejajar dengan mask.

Catatan :

• Bit diindeks 0: bit 0 adalah MSB.
• Asumsikan bahwa angka 8,9 tidak diperbolehkan dalam string mask.
• Input Strings termasuk karakter ASCII yang dapat dicetak.
• 'Nol' dan 'yang' disejajarkan dengan topeng.
• Untuk karakter khusus / pengubah dalam bahasa Anda: kami dapat menganggap mereka tidak akan muncul di string input.

Untuk kejelasan, lihat lebih banyak contoh.

Input -> Contoh output

Keluarkan semua 8 bit dalam urutan umum dengan pembatas ruang, dalam notasi oval-and-stick yang umum:

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

A=1 ->    0000 0001

Output dalam urutan terbalik, dalam notasi dasbor dan mesin terbang:

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

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

Beragam notasi dalam satu output, misalnya untuk data yang dikemas:

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

Pola berulang:

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

Memperbarui

Aturan telah sedikit disederhanakan - program harus mencetak satu angka saja (bukan array / daftar angka seperti yang diusulkan pada awalnya).

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

Parameter nol dan yang diperlakukan sebagai array ( *b) dan dengan parameter nol disimpan b[0]dan parameter yang disimpan dalam b[1].

Parameter mask fmemiliki setiap digit ( /\d/) diganti dengan karakter dari array yang sesuai. Variabel khusus $`, yang menahan teks mengarah ke kecocokan saat ini, adalah (ab) digunakan di sini untuk melacak posisi.

Pengindeksan bit Ruby memanggil 0 bit yang paling tidak signifikan, tetapi tantangan menyebut 0 bit yang paling signifikan. Pengurangan ASCII dari 55 (karakter '7') menghasilkan indeks bit Ruby yang dapat digunakan.

Cobalah online!

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

Mathematica, 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

Larutan:

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

Contoh:

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

Penjelasan:

Tarik keluar indeks di mana topeng input Madalah angka, sebut saja di msinilah kita akan memodifikasi masker input. Keluarkan angka dari string, masukkan ke integer dan kemudian indeks ke dalam array 8-bit kami untuk mendapatkan urutan yang benar. Gunakan array 8-bit ini untuk mengindeks ke dalam O(jika 1 diatur) atau Z(jika 0 diatur), dan kemudian indeks ke dalam daftar ini pada indeks yang diberikan oleh m. Akhirnya terapkan ( :) daftar baru ini ke topeng asli di indeks 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

Catatan:

Dapat mengurangi 14 byte lebih lanjut jika kami diizinkan memberikan argumen dalam bentuk:

[A;M;(Z;O)]

karena q memungkinkan hingga 3 argumen untuk diberikan ke suatu fungsi tanpa diberi nama secara eksplisit (yaitu x, ydan zmasing - masing):

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