Просматривать двоичные значения, напечатанные в виде овалов и палочек, не так просто ... Чтобы помочь с этим, вы должны написать функцию (или программу), которая печатает числа в пользовательском двоичном представлении.
Поэтому я хочу взять число, скажем 3 ( 00000011), и вывести биты в определенном пользователем формате, например, с разделенными пробелом парами:

00 00 00 11

или, скажем, в обратном порядке и с некоторыми декораторами, например:

11_00_00_00

Кроме того, должна быть возможность показывать «0» и «1» в качестве пользовательских символов, чтобы лучше их различать, например:

XX oo oo oo

Поэтому задача состоит в том, чтобы написать код, который делает все это в соответствии со следующей спецификацией.

Спецификация

Функция принимает входные данные следующим образом: f (A, маска, нули, единицы)

Параметры:

A - номер входа - любое (без знака) целое число в диапазоне 0-255.
маска - строковый параметр, который определяет структуру вывода.
нули - строка одинаковой длины, определяющая «нулевые» глифы для каждого выходного слота.
ones - строка одинаковой длины, определяющая символы «один» для каждого выходного слота.

Правила оформления выхода:

Посмотрите на это изображение с примером внимательно, чтобы понять, как генерируется вывод:

Таким образом, только отдельные цифры в маске анализируются и заменяются соответствующими битами A, остальные символы остаются как есть . Кроме того, если значение взятого бита равно 1, то в конечном выводе оно отображается как «X», а если оно равно 0, то оно отображается как «o». В приведенном выше примере все четыре взятых бита равны «1», поэтому мы видим «X» во всех слотах.

Если бы входное число было 128, то, по логике, выходной будет X foo bar ooo. Символы в параметрах «нули» и «единицы»: любые печатные символы ASCII, если они всегда выровнены по маске с маской.

Примечания :

• Биты с 0 индексами: 0-й бит - это MSB.
• Предположим, что цифры 8,9 не допускаются в строке маски.
• Входные строки включают любые печатные символы ASCII.
• «Нули» и «единицы» выровнены по маске с маской.
• Для специальных символов / модификаторов на вашем языке: мы можем предположить, что они не появятся во входной строке.

Для наглядности смотрите другие примеры.

Вход -> Примеры вывода

Выведите все 8 битов в общем порядке с разделителем пробела, в общепринятых обозначениях овала и ручки:

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

A=1 ->    0000 0001

Вывести в обратном порядке, в тире-и-глифах:

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

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

Различные обозначения в одном выводе, например, для упакованных данных:

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

Повторяющиеся шаблоны:

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

Обновить

Правила были немного упрощены - программа должна печатать только одно число (не массив / список чисел, как было предложено изначально).

JavaScript (ES6), 57 байт

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

Рубин , 48 байтов

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

Параметры с нулями и единицами обрабатываются как array ( *b), а параметр с нулями сохраняется в, b[0]а параметр none - в b[1].

В параметре маски fкаждая цифра ( /\d/) заменяется символом из соответствующего массива. Специальная переменная $`, которая содержит текст, ведущий к текущему совпадению, - это (ab), используемая здесь для отслеживания положения.

Индексирование битов в Ruby вызывает 0 младший значащий бит, но вызов вызывает 0 самый старший бит. Вычитание ASCII из 55 (символ '7') дает пригодный для использования индексный бит Ruby.

Попробуйте онлайн!

Perl 6 , 60 байт

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

Python, 97 байт

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 байт

""<>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 байта

Решение:

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

Примеры:

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

Объяснение:

Вытащите индексы, где входная маска Mявляется цифрой, назовите ее, mгде мы будем изменять входную маску. Возьмите цифры из строки, приведите к целым числам, а затем внесите указатель в наш 8-битный массив, чтобы получить правильный порядок. Используйте этот 8-битный массив для индексации либо O(если установлено 1), либо Z(если установлено 0), а затем внесите их в эти списки по индексам, заданным в m. Наконец примените ( :) этот новый список к исходной маске по индексам 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

Ноты:

Можно было бы сбрить еще 14 байтов, если бы нам было разрешено приводить аргументы в форме:

[A;M;(Z;O)]

а д позволяет до 3 -х аргументов следует уделить функции без явного имени (они x, yи zсоответственно):

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