Observar os valores binários impressos como ovais e paus não é tão fácil ... Para ajudar nisso, você deve escrever uma função (ou um programa) que imprima números na representação binária personalizada.
Então, eu quero pegar um número, digamos 3 ( 00000011) e gerar os bits no formato definido pelo usuário, por exemplo, com pares separados por espaço:

00 00 00 11

ou, digamos, em ordem inversa e com alguns decoradores, por exemplo:

11_00_00_00

Além disso, deve haver a possibilidade de mostrar '0' e '1' como caracteres personalizados para distingui-los melhor, por exemplo:

XX oo oo oo

Portanto, o desafio é escrever o código que faz isso dentro da seguinte especificação.

Especificação

A função recebe entradas assim: f (A, máscara, zeros, uns)

Parâmetros:

A - número de entrada - qualquer número inteiro (sem sinal) no intervalo de 0 a 255.
mask - um parâmetro de string que define a construção da saída.
zeros - uma string do mesmo comprimento, define glifos 'zero' para cada slot de saída.
ones - uma string do mesmo comprimento, define glifos 'one' para cada slot de saída.

Regras para a construção da saída:

Olhe esta imagem com exemplo de perto para entender como a saída é gerada:

Portanto, apenas os dígitos únicos na máscara são analisados ​​e substituídos pelos bits correspondentes de A; outros caracteres são deixados como estão . Além disso, se o valor do bit obtido for 1, ele será exibido na saída final como "X" e, se for 0, será exibido como "o". No exemplo acima, todos os quatro bits obtidos são "1"; portanto, vemos "X" em todos os slots.

Se o número de entrada fosse 128, logicamente, a saída seria X foo bar ooo. Caracteres nos parâmetros "zeros" e "ones": qualquer caractere ASCII imprimível, assume que eles estão sempre alinhados com a máscara.

Notas :

• Os bits são indexados em 0: o bit 0 é o MSB.
• Suponha que os dígitos 8,9 não sejam permitidos na sequência de máscaras.
• As seqüências de entrada incluem quaisquer caracteres ASCII imprimíveis.
• 'Zeros' e 'ones' são alinhados com a máscara.
• Para caracteres / modificadores especiais no seu idioma: podemos assumir que eles não aparecerão na string de entrada.

Para maior clareza, veja mais exemplos.

Entrada -> Exemplos de saída

Envie todos os 8 bits em ordem comum com um delimitador de espaço, na notação oval e em stick comum:

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

A=1 ->    0000 0001

Saída em ordem inversa, em notação de traço e glifo:

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

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

Notações diversas em uma saída, por exemplo, para dados compactados:

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

Padrões de repetição:

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

Atualizar

As regras foram ligeiramente simplificadas - o programa deve imprimir apenas um número (não matriz / lista de números, como foi proposto inicialmente).

JavaScript (ES6), 57 bytes

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

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

Os parâmetros zeros e uns são tratados como uma matriz ( *b) e com o parâmetro zeros é armazenado b[0]e o parâmetro ones é armazenado em b[1].

O parâmetro mask ftem cada dígito ( /\d/) substituído por um caractere da matriz apropriada. A variável especial $`, que contém o texto que antecede a correspondência atual, é (ab) usada aqui para acompanhar a posição.

A indexação de bits de Ruby chama 0 de bit menos significativo, mas o desafio chama 0 de bit mais significativo. A subtração ASCII de 55 (o caractere '7') gera um índice de bits Ruby utilizável.

Experimente online!

Perl 6 , 60 bytes

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

Python, 97 bytes

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 bytes

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

Solução:

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

Exemplos:

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

Explicação:

Retire os índices onde a máscara de entrada Mé um numeral, chame-a de mque iremos modificar a máscara de entrada. Retire os números da string, converta-os para números inteiros e depois indexe em nossa matriz de 8 bits para obter a ordem correta. Use essa matriz de 8 bits para indexar O(se 1 estiver definido) ou Z(se 0 estiver definido) e, em seguida, indexe nessas listas nos índices dados por m. Por fim, aplique ( :) essa nova lista à máscara original nos índices 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

Notas:

Poderia cortar mais 14 bytes se nos fosse permitido fornecer os argumentos no formato:

[A;M;(Z;O)]

como q permite até 3 argumentos para ser dado a uma função sem ser explicitamente nomeado (eles são x, ye zrespectivamente):

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