Regarder les valeurs binaires imprimées sous forme d'ovales et de bâtons n'est pas si facile ... Pour vous aider, vous devez écrire une fonction (ou un programme) qui imprime des nombres dans une représentation binaire personnalisée.
Je veux donc prendre un nombre, disons 3 ( 00000011) et sortir les bits dans un format défini par l'utilisateur, par exemple avec des paires séparées par des espaces:

00 00 00 11

ou, par exemple, dans l'ordre inverse et avec certains décorateurs, par exemple:

11_00_00_00

De plus, il doit être possible d'afficher «0» et «1» comme caractères personnalisés pour mieux les distinguer, par exemple:

XX oo oo oo

Le défi consiste donc à écrire le code qui fait tout cela dans la spécification suivante.

spécification

La fonction prend une entrée comme ceci: f (A, masque, zéros, uns)

Paramètres:

A - numéro d'entrée - tout entier (non signé) compris entre 0 et 255.
mask - un paramètre de chaîne qui définit la construction de la sortie.
zéros - une chaîne de même longueur, définit des glyphes «zéro» pour chaque emplacement de sortie.
uns - une chaîne de même longueur, définit des glyphes «un» pour chaque emplacement de sortie.

Règles pour la construction de sortie:

Regardez attentivement cette image avec un exemple pour comprendre comment la sortie est générée:

Ainsi, seuls les chiffres uniques du masque sont analysés et remplacés par les bits correspondants de A, les autres caractères restent tels quels . De plus, si la valeur du bit pris est 1 alors il apparaît dans la sortie finale comme "X" et s'il est 0 alors il apparaît comme "o". Dans l'exemple ci-dessus, les quatre bits pris sont tous "1", nous voyons donc "X" dans tous les emplacements.

Si le numéro d'entrée était 128, alors, logiquement, la sortie serait X foo bar ooo. Caractères dans les paramètres "zéros" et "uns": tous les caractères ASCII imprimables, supposons qu'ils sont toujours alignés sur le masque.

Remarques :

• Les bits sont indexés 0: le 0e bit est le MSB.
• Supposons que les chiffres 8,9 ne sont pas autorisés dans la chaîne de masque.
• Les chaînes d'entrée incluent tous les caractères ASCII imprimables.
• Les «zéros» et les «uns» sont alignés en caractères avec le masque.
• Pour les caractères spéciaux / modificateurs dans votre langue: nous pouvons supposer qu'ils n'apparaîtront pas dans la chaîne d'entrée.

Pour plus de clarté, voir plus d'exemples.

Entrée -> Exemples de sortie

Sortie tous les 8 bits dans un ordre commun avec un délimiteur d'espace, en notation ovale et bâton commune:

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

A=1 ->    0000 0001

Sortie dans l'ordre inverse, en notation tiret et glyphe:

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

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

Diverses notations dans une sortie, par exemple pour les données compressées:

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

Modèles répétitifs:

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

Mise à jour

Les règles ont été légèrement simplifiées - le programme doit imprimer un seul numéro (pas un tableau / une liste de nombres comme il a été proposé initialement).

JavaScript (ES6), 57 octets

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

Rubis , 48 octets

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

Les paramètres zéros et uns sont traités comme un tableau ( *b) et avec le paramètre zéros est stocké dans b[0]et le paramètre uns stocké dans b[1].

Le paramètre mask fa chaque chiffre ( /\d/) substitué par un caractère du tableau approprié. La variable spéciale $`, qui contient le texte menant à la correspondance actuelle, est (ab) utilisée ici pour garder une trace de la position.

L'indexation des bits de Ruby appelle 0 le bit le moins significatif, mais le défi appelle 0 le bit le plus significatif. La soustraction ASCII de 55 (le caractère '7') donne un index de bit Ruby utilisable.

Essayez-le en ligne!

Perl 6 , 60 octets

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

Python, 97 octets

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 octets

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

Solution:

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

Exemples:

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

Explication:

Retirez les indices où le masque de saisie Mest un chiffre, appelez-le c'est mlà que nous allons modifier le masque de saisie. Retirez les chiffres de la chaîne, convertissez-les en nombres entiers, puis indexez-les dans notre tableau 8 bits pour obtenir le bon ordre. Utilisez ce tableau de 8 bits pour indexer dans O(si 1 est défini) ou Z(si 0 est défini), puis indexez dans ces listes aux indices donnés par m. Enfin, appliquez ( :) cette nouvelle liste au masque d'origine aux indices 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

Remarques:

Pourrait raser 14 octets supplémentaires si nous étions autorisés à donner les arguments sous la forme:

[A;M;(Z;O)]

comme q permet jusqu'à 3 arguments à donner à une fonction sans être explicitement nommée (ils sont x, yet zrespectivement):

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