Ovaller ve çubuklar olarak yazdırılan ikili değerlere göz atmak o kadar kolay değildir ... Buna yardımcı olmak için, sayıları özel ikili sunumda yazdıran bir işlev (veya bir program) yazmalısınız.
Bu nedenle, 3 ( 00000011) diyelim bir sayı almak ve bitleri kullanıcı tanımlı biçimde, örneğin boşlukla ayrılmış çiftlerle çıktılamak istiyorum:

00 00 00 11

veya diyelim ki, ters sırada ve bazı dekoratörler ile, örneğin:

11_00_00_00

Ayrıca, onları daha iyi ayırt etmek için '0' ve '1'i özel karakterler olarak gösterme olasılığı olmalıdır, örneğin:

XX oo oo oo

Bu yüzden zorluk, aşağıdaki spesifikasyonda hepsini yapan kodu yazmaktır.

Şartname

İşlev şu şekilde girdi alır: f (A, maske, sıfırlar, olanlar)

Parametreler:

A - giriş numarası - 0-255 aralığında herhangi bir (işaretsiz) tam sayı.
mask - çıktının yapısını tanımlayan bir dize parametresi.
sıfırlar - aynı uzunlukta bir dize, her bir çıkış yuvası için 'sıfır' glifleri tanımlar.
biri - aynı uzunlukta bir dize, her bir çıkış yuvası için 'bir' glif tanımlar.

Çıktı yapımı için kurallar:

Çıktının nasıl üretildiğini anlamak için bu görüntüye örnekle yakından bakın:

Bu nedenle, yalnızca maskedeki tek basamaklar ayrıştırılır ve A'nın karşılık gelen bitleriyle değiştirilir, diğer karakterler olduğu gibi bırakılır . Ayrıca, alınan bitin değeri 1 ise son çıkışta "X" olarak ve 0 ise "o" olarak görünür. Yukarıdaki örnekte, alınan dört bitin hepsi "1" dir, bu nedenle tüm yuvalarda "X" değerini görürüz.

Girdi numarası 128 olsaydı, mantıksal olarak, çıktı olur X foo bar ooo. "Sıfırlar" ve "olanlar" parametrelerindeki karakterler: yazdırılabilir ASCII karakterleri, her zaman maske ile karakter hizalandığını varsayar.

Notlar :

• Bitler 0 dizinlidir: 0. bit MSB'dir.
• Maske dizesinde 8,9 rakamlarına izin verilmediğini varsayın.
• Giriş Dizeleri yazdırılabilir ASCII karakterlerini içerir.
• 'Sıfırlar' ve 'olanlar' maske ile karakterizedir.
• Dilinizdeki özel karakterler / değiştiriciler için: giriş dizesinde görünmeyeceklerini varsayabiliriz.

Anlaşılır olması için daha fazla örneğe bakın.

Girdi -> Çıktı örnekleri

8 bitin tümünü ortak oval sıva notasyonunda bir boşluk sınırlayıcıyla ortak sırayla çıktılayın:

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

A=1 ->    0000 0001

Çıktı ters sırayla, tire ve glif gösterimi biçiminde:

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

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

Bir çıktıda çeşitli gösterimler, örneğin paketlenmiş veriler için:

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

Yinelenen desenler:

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

Güncelleme

Kurallar biraz basitleştirilmiştir - program yalnızca bir sayı yazdırmalıdır (başlangıçta önerildiği gibi dizi / sayı listesi değil).

JavaScript (ES6), 57 bayt

(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 bayt

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

Sıfırlar ve birler parametreleri bir dizi ( *b) olarak ele alınır ve sıfırlar parametresi ile depolanır b[0]ve birler parametresi depolanır b[1].

Mask parametresi f, her /\d/diziye ( ) uygun dizideki bir karakterle değiştirilir. $`Geçerli eşleşmeye kadar giden metni tutan özel değişken (ab) burada pozisyonu takip etmek için kullanılır.

Ruby'nin bit indekslemesi 0'ı en az anlamlı bit olarak adlandırır, ancak meydan okuma 0'ı en önemli bit olarak adlandırır. ASCII'nin 55'ten ('7' karakteri) çıkarılması kullanılabilir bir Ruby bit indeksi verir.

Çevrimiçi deneyin!

Perl 6 , 60 bayt

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

Python, 97 bayt

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 bayt

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

Çözüm:

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

Örnekler:

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

Açıklama:

Giriş maskesinin Mbir sayı olduğu indeksleri çıkarın , buna mgiriş maskesini değiştireceğimiz yer deyin . Sayıları dizeden çıkarın, tamsayılara yayınlayın ve ardından doğru sıralamayı elde etmek için 8 bit dizimize dizin. Bu 8-bit diziyi O(1 ayarlanmışsa) veya Z(0 ayarlanmışsa) dizinlemek için kullanın ve sonra tarafından verilen dizinlerde bu listelere dizin oluşturun m. Son olarak :bu yeni listeyi dizinlerdeki orijinal maskeye uygulayın ( ) 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

Notlar:

Formdaki argümanları vermemize izin verilirse 14 bayt daha tıraş edilebilir:

[A;M;(Z;O)]

q3 argümanları kadar olanak sağladığı için, (bunlar açıkça adlı olmadan bir fonksiyonu verilecek x, yve zsırası ile):

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