Il bulbo oculare dei valori binari stampati come ovali e bastoncini non è così facile ... Per aiutarti, devi scrivere una funzione (o un programma) che stampa i numeri nella rappresentazione binaria personalizzata.
Quindi voglio prendere un numero, dire 3 ( 00000011) e generare i bit in un formato definito dall'utente, ad esempio con coppie separate da spazio:

00 00 00 11

o, diciamo, in ordine inverso e con alcuni decoratori, ad esempio:

11_00_00_00

Inoltre, ci deve essere la possibilità di mostrare '0' e '1' come caratteri personalizzati per distinguerli meglio, ad esempio:

XX oo oo oo

Quindi la sfida è scrivere il codice che fa tutto ciò con la seguente specifica.

specificazione

La funzione accetta input in questo modo: f (A, maschera, zeri, uno)

parametri:

A - numero di input - qualsiasi numero intero (senza segno) nell'intervallo 0-255.
maschera - un parametro stringa che definisce la costruzione dell'output.
zeri - una stringa della stessa lunghezza, definisce glifi "zero" per ogni slot di uscita.
uni - una stringa della stessa lunghezza, definisce glifi "uno" per ogni slot di uscita.

Regole per la costruzione dell'output:

Guarda questa immagine con l'esempio da vicino per capire come viene generato l'output:

Quindi solo le singole cifre nella maschera vengono analizzate e sostituite dai corrispondenti bit di A, gli altri caratteri vengono lasciati così come sono . Inoltre, se il valore del bit rilevato è 1, viene visualizzato nell'uscita finale come "X" e se è 0, viene visualizzato come "o". Nell'esempio sopra tutti e quattro i bit presi sono "1", quindi vediamo "X" in tutti gli slot.

Se il numero di input fosse 128, logicamente, l'output sarebbe X foo bar ooo. Caratteri nei parametri "zeri" e "uni": qualsiasi carattere ASCII stampabile, si presume che siano sempre allineati ai caratteri con la maschera.

Note :

• I bit sono indicizzati 0: 0 ° bit è l'MSB.
• Supponiamo che le cifre 8,9 non siano consentite nella stringa della maschera.
• Le stringhe di input includono tutti i caratteri ASCII stampabili.
• 'Zeri' e 'uni' sono allineati al carattere con la maschera.
• Per caratteri / modificatori speciali nella tua lingua: possiamo presumere che non appariranno nella stringa di input.

Per la chiarezza, vedi altri esempi.

Input -> Esempi di output

Emette tutti gli 8 bit in ordine comune con un delimitatore di spazio, in notazione ovale e stick comune:

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

A=1 ->    0000 0001

Uscita in ordine inverso, in notazione trattino e glifo:

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

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

Diverse notazioni in un output, ad es. Per dati compressi:

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

Motivi ripetuti:

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

Aggiornare

Le regole sono state leggermente semplificate: il programma deve stampare un solo numero (non matrice / elenco di numeri come inizialmente proposto).

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

Rubino , 48 byte

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

I parametri zero e quelli sono trattati come un array ( *b) e con il parametro zero viene archiviato b[0]e quelli memorizzati b[1].

Il parametro maschera fha ogni cifra ( /\d/) sostituita con un carattere dall'array appropriato. La variabile speciale $`, che contiene il testo che porta alla corrispondenza corrente, è (ab) usata qui per tenere traccia della posizione.

L'indicizzazione dei bit di Ruby chiama 0 il bit meno significativo, ma la sfida chiama 0 il bit più significativo. La sottrazione ASCII da 55 (il carattere '7') produce un indice di bit Ruby utilizzabile.

Provalo 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

Soluzione:

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

Esempi:

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

Spiegazione:

Estrai gli indici dove la maschera di input Mè un numero, chiamala mqui è dove modificheremo la maschera di input. Prendi i numeri dalla stringa, esegui il cast in numeri interi e quindi indicizza nel nostro array a 8 bit per ottenere l'ordinamento corretto. Utilizzare questo array a 8 bit per indicizzare in O(se è impostato 1) o Z(se è impostato 0), quindi indicizzare in questi elenchi gli indici forniti da m. Infine applica ( :) questo nuovo elenco alla maschera originale agli indici 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

Appunti:

Potremmo radere altri 14 byte se ci fosse permesso di fornire gli argomenti nel modulo:

[A;M;(Z;O)]

come q permette fino a 3 argomenti da dare a una funzione senza essere esplicitamente chiamato (sono x, ye zrispettivamente):

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