Observar los valores binarios impresos como óvalos y barras no es tan fácil ... Para ayudar con eso, debe escribir una función (o un programa) que imprima números en una representación binaria personalizada.
Así que quiero tomar un número, digamos 3 ( 00000011) y generar los bits en formato definido por el usuario, por ejemplo con pares separados por espacios:

00 00 00 11

o, por ejemplo, en orden inverso y con algunos decoradores, por ejemplo:

11_00_00_00

Además, debe existir la posibilidad de mostrar '0' y '1' como caracteres personalizados para distinguirlos mejor, por ejemplo:

XX oo oo oo

Entonces, el desafío es escribir el código que lo hace todo dentro de la siguiente especificación.

Especificación

La función toma datos como este: f (A, máscara, ceros, unos)

Parámetros:

A - número de entrada - cualquier número entero (sin signo) en el rango 0-255.
máscara : un parámetro de cadena que define la construcción de la salida.
ceros : una cadena de la misma longitud, define glifos 'cero' para cada ranura de salida.
ones : una cadena de la misma longitud, define 'uno' glifos para cada ranura de salida.

Reglas para la construcción de salida:

Mire esta imagen con un ejemplo de cerca para comprender cómo se genera la salida:

Por lo tanto, solo los dígitos individuales de la máscara se analizan y reemplazan por los bits correspondientes de A, los demás caracteres se dejan como están . Además, si el valor del bit tomado es 1, aparece en la salida final como "X" y si es 0, aparece como "o". En el ejemplo anterior, los cuatro bits tomados son "1", por lo que vemos "X" en todas las ranuras.

Si el número de entrada fuera 128, entonces, lógicamente, la salida sería X foo bar ooo. Caracteres en los parámetros "ceros" y "unos": cualquier carácter ASCII imprimible, suponga que siempre están alineados con la máscara.

Notas :

• Los bits están indexados a 0: el bit 0 es el MSB.
• Suponga que los dígitos 8,9 no están permitidos en la cadena de máscara.
• Las cadenas de entrada incluyen caracteres ASCII imprimibles.
• 'Ceros' y 'unos' están alineados con la máscara.
• Para caracteres / modificadores especiales en su idioma: podemos suponer que no aparecerán en la cadena de entrada.

Para mayor claridad, vea más ejemplos.

Entrada -> Ejemplos de salida

Imprima los 8 bits en orden común con un delimitador de espacio, en notación común de óvalo y barra:

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

A=1 ->    0000 0001

Salida en orden inverso, en notación guión y glifo:

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

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

Diversas anotaciones en una salida, por ejemplo, para datos empaquetados:

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

Patrones repetitivos:

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

Actualizar

Las reglas se han simplificado ligeramente: el programa debe imprimir solo un número (no una matriz / lista de números como se propuso 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]}}

Los parámetros ceros y unos se tratan como una matriz ( *b) y con el parámetro ceros se almacena b[0]y los parámetros unos se almacenan en b[1].

El parámetro de máscara ftiene cada dígito ( /\d/) sustituido con un carácter de la matriz apropiada. La variable especial $`, que contiene el texto que conduce a la coincidencia actual, se usa (ab) aquí para realizar un seguimiento de la posición.

La indexación de bits de Ruby llama a 0 el bit menos significativo, pero el desafío llama a 0 el bit más significativo. La sustracción ASCII de 55 (el carácter '7') produce un índice de bits Ruby utilizable.

Pruébalo en línea!

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

Solución:

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

Ejemplos:

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

Explicación:

Extraiga los índices donde la máscara de entrada Mes un número, llámelo maquí donde modificaremos la máscara de entrada. Saque los números de la cadena, conviértalos en enteros y luego indexe en nuestra matriz de 8 bits para obtener el orden correcto. Utilice esta matriz de 8 bits para indexar en O(si se establece 1) o Z(si se establece 0), y luego indexar en estas listas en los índices dados por m. Finalmente aplique ( :) esta nueva lista a la máscara original en los í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:

Podría reducir otros 14 bytes si se nos permitiera dar los argumentos en la forma:

[A;M;(Z;O)]

como q permite que se den hasta 3 argumentos a una función sin ser explícitamente nombrados (son x, yy zrespectivamente):

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