Es ist nicht so einfach, die als Ovale und Sticks gedruckten Binärwerte zu betrachten ... Um dies zu unterstützen, müssen Sie eine Funktion (oder ein Programm) schreiben, die Zahlen in einer benutzerdefinierten Binärdarstellung druckt.
Ich möchte also eine Zahl, z. B. 3 ( 00000011), nehmen und die Bits in einem benutzerdefinierten Format ausgeben, beispielsweise mit durch Leerzeichen getrennten Paaren:

00 00 00 11

oder beispielsweise in umgekehrter Reihenfolge und mit einigen Dekorateuren, z.

11_00_00_00

Darüber hinaus muss es möglich sein, '0' und '1' als benutzerdefinierte Zeichen anzuzeigen, um sie besser unterscheiden zu können, z.

XX oo oo oo

Die Herausforderung besteht also darin, den Code zu schreiben, der dies alles innerhalb der folgenden Spezifikation tut.

Spezifikation

Die Funktion nimmt folgende Eingabe vor: f (A, Maske, Nullen, Einsen)

Parameter:

A - Eingangsnummer - eine beliebige (vorzeichenlose) Ganzzahl im Bereich von 0 bis 255.
mask - Ein String-Parameter, der den Aufbau der Ausgabe definiert.
Nullen - Eine Zeichenfolge mit derselben Länge definiert 'Null'-Glyphen für jeden Ausgangssteckplatz.
one - Eine Zeichenfolge mit der gleichen Länge definiert 'eine' Glyphe für jeden Ausgabeschlitz.

Regeln für die Ausgabekonstruktion:

Schauen Sie sich dieses Bild mit einem Beispiel genau an, um zu verstehen, wie die Ausgabe generiert wird:

Es werden also nur die einzelnen Ziffern in der Maske analysiert und durch entsprechende Bits von A ersetzt. Andere Zeichen bleiben unverändert . Wenn der Wert des aufgenommenen Bits 1 ist, wird es in der endgültigen Ausgabe als "X" angezeigt, und wenn es 0 ist, wird es als "o" angezeigt. Im obigen Beispiel sind alle vier genommenen Bits "1", so dass wir "X" in allen Slots sehen.

Wenn die Eingabenummer 128 wäre, wäre die Ausgabe logischerweise X foo bar ooo. Zeichen in den Parametern "Nullen" und "Einsen": Bei allen druckbaren ASCII-Zeichen wird davon ausgegangen, dass sie immer an der Maske ausgerichtet sind.

Anmerkungen :

• Bits sind 0-indiziert: Das 0. Bit ist das MSB.
• Angenommen, die Ziffern 8,9 sind in der Maskenzeichenfolge nicht zulässig.
• Die Eingabezeichenfolgen enthalten alle druckbaren ASCII-Zeichen.
• 'Nullen' und 'Einsen' sind auf die Maske ausgerichtet.
• Für Sonderzeichen / Modifikatoren in Ihrer Sprache: Wir können davon ausgehen, dass sie nicht in der Eingabezeichenfolge angezeigt werden.

Weitere Informationen finden Sie in der Übersicht.

Eingabe -> Ausgabebeispiele

Geben Sie alle 8 Bits in gemeinsamer Reihenfolge mit einem Leerzeichen in gemeinsamer Oval-and-Stick-Notation aus:

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

A=1 ->    0000 0001

Ausgabe in umgekehrter Reihenfolge, in Strich-und-Glyphe-Notation:

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

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

Verschiedene Notationen in einer Ausgabe, zB für gepackte Daten:

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

Wiederholte Muster:

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

Aktualisieren

Die Regeln wurden leicht vereinfacht - das Programm darf nur eine Nummer drucken (nicht Array / Liste von Nummern, wie es ursprünglich vorgeschlagen wurde).

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

Ruby , 48 Bytes

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

Die Parameter Nullen und Einsen werden als Array ( *b) behandelt und mit dem Parameter Nullen b[0]und dem Parameter Einsen gespeichert b[1].

Beim Maskenparameter fwird jede Ziffer ( /\d/) durch ein Zeichen aus dem entsprechenden Array ersetzt. Die spezielle Variable $`, die den Text enthält, der zur aktuellen Übereinstimmung führt, wird hier (ab) verwendet, um die Position zu verfolgen.

Rubys Bitindizierung ruft 0 das niedrigstwertige Bit auf, aber die Herausforderung nennt 0 das höchstwertige Bit. Die ASCII-Subtraktion von 55 (das Zeichen '7') ergibt einen verwendbaren Ruby-Bitindex.

Probieren Sie es online aus!

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

Lösung:

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

Beispiele:

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

Erläuterung:

Ziehen Sie Indizes heraus, bei denen die Eingabemaske Meine Ziffer ist, und nennen Sie sie mhier. Hier werden wir die Eingabemaske ändern. Nehmen Sie die Ziffern aus der Zeichenfolge, wandeln Sie sie in Ganzzahlen um und indizieren Sie sie dann in unser 8-Bit-Array, um die richtige Reihenfolge zu erhalten. Verwenden Sie dieses 8-Bit-Array, um entweder O(wenn 1 festgelegt ist) oder Z(wenn 0 festgelegt ist) zu indizieren und dann an den durch angegebenen Indizes in diese Listen zu indizieren m. Wenden Sie ( :) schließlich diese neue Liste auf die ursprüngliche Maske bei Indizes an 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

Anmerkungen:

Könnte weitere 14 Bytes sparen, wenn wir die Argumente in der folgenden Form angeben könnten:

[A;M;(Z;O)]

als q für 3 Argumente ermöglicht , ohne explizit genannt zu werden zu einer Funktion gegeben werden (sie sind x, yund zjeweils):

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