Введение

Я не особенно знаю, откуда взялась эта тенденция. Это может быть просто мем или что-то, но это несколько популярно.

Вызов

Ваша задача сегодня - преобразовать Fizz Buzz в двоичный файл (0, 1) соответственно и преобразовать этот двоичный файл в текстовый. Довольно стандартные вещи.

Как это работает?

FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz будет переводить в 01101000 01101001, а затем переводится в "привет"

Ограничения

• Вводом является Fizz Buzz в двоичной точке зрения (см. Примеры ниже.)
• Вывод должен быть текстом.
• Вы можете предположить, что вход FizzBuzz правильный.
• Это код-гольф , выигрывают короткие байты.

вход

FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzzBuzzFizzBuzzFizzFizzBuzz FizzФиззБуззФизФизФизСерзФиззБизз

Выход

"Здравствуй!"

C, 59 байт

i;f(char*s){while(*s&3?*s&9||(i+=i+*s%5):putchar(i),*s++);}

Магические числа, магические числа везде!

(Кроме того, C короче, чем Python, JS, PHP и Ruby? Не слышно!)

Это функция, которая принимает строку в качестве входных данных и выводит их в STDOUT.

Прохождение

Базовая структура:

i;           // initialize an integer i to 0
f(char*s){
while(...);  // run the stuff inside until it becomes 0
}

Здесь «вещи внутри» - это набор кода, за которым следует оператор ,*s++запятой, который возвращает только значение своего второго аргумента. Следовательно, он будет проходить через строку и устанавливаться *sдля каждого символа, включая завершающий байт NUL (поскольку postfix ++возвращает предыдущее значение), перед выходом.

Давайте посмотрим на остальное:

*s&3?*s&9||(i+=i+*s%5):putchar(i)

Сняв тройное и короткое замыкание ||, это можно расширить до

if (*s & 3) {
    if (!(*s & 9)) {
        i += i + *s % 5;
    }
} else {
    putchar(i);
}

Откуда берутся эти магические числа? Вот двоичные представления всех задействованных символов:

F  70  01000110
B  66  01000010
i  105 01101001
z  122 01111010
u  117 01110101
   32  00100000
\0 0   00000000

Во-первых, нам нужно отделить пробел и NUL от остальных символов. Как работает этот алгоритм, он сохраняет накопитель «текущего» числа и печатает его всякий раз, когда он достигает пробела или конца строки (то есть '\0'). Заметив, что ' 'и '\0'являются единственными символами, которые не имеют ни одного из двух младших значащих битов, мы можем побитово И символ 0b11получить, чтобы получить ноль, если символ является пробелом или NUL и ненулевым в противном случае.

Копая глубже, в первой ветке "если" у нас теперь есть персонаж, один из которых FBizu. Я выбрал только обновить аккумулятор на Fs и Bs, поэтому мне нужен был способ отфильтровать izus. Удобно, Fи для Bобоих установлены только второй, третий или седьмой младший значащий бит, а для всех остальных чисел установлен по меньшей мере один другой бит. На самом деле все они имеют первый или четвертый младший бит. Следовательно, мы можем поразрядно AND с 0b00001001, который равен 9, что даст 0 для Fи Bи ненулевой в противном случае.

Как только мы определили, что у нас есть Fили B, мы можем сопоставить их 0и, 1соответственно, взяв их модуль 5, потому что Fесть 70и Bесть 66. Тогда фрагмент

i += i + *s % 5;

это просто способ сказать

i = (i * 2) + (*s % 5);

который также может быть выражен как

i = (i << 1) | (*s % 5);

который вставляет новый бит в наименее значимую позицию и сдвигает все остальное на 1.

"Но ждать!" Вы могли бы возразить. «Когда вы печатаете i, когда он возвращается к 0?» Ну, putcharприведем свой аргумент к an unsigned char, который просто так получается размером 8 бит. Это означает, что все, что осталось за восьмым младшим значащим битом (т.е. мусор из предыдущих итераций), отброшено, и нам не нужно об этом беспокоиться.

Спасибо @ETHproductions за предложение заменить 57на 9, сохраняя байт!

Желе , 9 байт

Ḳm€4O%5ḄỌ

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

Bash + coreutils, 61 50 байт

(-11 байт благодаря дверной ручке !)

tr -d izu<<<$1|tr FB 01|dc -e'2i?[aPz0<k]dskx'|rev

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

Python 3 , 169 101 93 91 85 81 байт

lambda s,j="".join:j(chr(int(j('01'[b<"C"])for b in c[::4]),2))for c in s.split())

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

Объяснение:

lambda s,j="".join:  # Create a lambda function
    j(  # call "".join, adds characters together with nothing in between
        chr(  # character by int
            int(  # string to int
                j(  # "".join again
                    '01'[b<"C"]  # 1 or 0, based on what character we get
                    for b in c[::4]  # For every first of 4 characters
                ),
                2)  # Base 2
        )
        for c in s.split()  # for every group of Fizz and Buzz with any whitespace character after it
    )

JavaScript (ES6), 80 79 байт

let f =

s=>`${s} `.replace(/.{4} ?/g,m=>m[s=s*2|m<'F',4]?String.fromCharCode(s&255):'')

console.log(f("FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"))

Japt , 26 24 19 17 байт

¸®ë4 ®c u5Ãn2 dÃq

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

Сохранено 2 байта благодаря @Shaggy и 2 байта благодаря @ETHproductions

объяснение

input: "FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"

¸®                // ["FizzBuzzBuzzFizzBuzzFizzFizzFizz","FizzBuzzBuzzFizzBuzzFizzFizzBuzz","FizzFizzBuzzFizzFizzFizzFizzBuzz"]
  ë4              // ["FBBFBFFF","FBBFBFFB","FFBFFFFB"]
     ®c           // [[70,66,66,70,66,70,70,70],[70,66,66,70,66,70,70,66],[70,70,66,70,70,70,70,66]]
        u5Ã       // ["01101000","01101001","00100001"]
           n2     // [104,105,33]
              d   // ["h","i","!"]
               Ãq // "hi!"

Рубин, 65 63 60 байт

->s{s.split.map{|x|x.gsub(/..../){$&.ord%5}.to_i(2).chr}*''}

Это анонимный процесс, который принимает данные и выводит их в виде строки.

->s{
s.split            # split on whitespace
.map{|x|           # for each word as x,
  x.gsub(/..../){  # replace each sequence of four characters with
    $&.ord%5       # the ASCII value of the first character, mod 5
                   # F is 70, B is 66, so this yields 0 for Fizz and 1 for Buzz
  }.to_i(2)        # interpret as a binary number
  .chr             # the character with this ASCII value
}*''               # join on empty string
}

JavaScript (ES6), 95 88 85 81 байт

s=>s.replace(/..zz/g,m=>m<"F"|0).replace(/\d+ ?/g,m=>String.fromCharCode("0b"+m))

• 4 байта сохранены благодаря ETHproductions .

Попытайся

f=
s=>s.replace(/..zz/g,m=>m<"F"|0).replace(/\d+ ?/g,m=>String.fromCharCode("0b"+m))
oninput=_=>o.innerText=f(i.value)
o.innerText=f(i.value="FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz")

*{font-family:sans-serif}

<input id=i><p id=o>

Perl 5, 33 байта

print(pack'B*',<>=~y/FB -z/01/dr)

Заменяет 'F' и 'B' на входе соответственно на 0 и 1 и удаляет другие символы. Затем он использует packфункцию perl для преобразования этой битовой строки в символы ASCII.

Python 2 , 90 83 82 81 байт

^{-1 байт благодаря полностью человеческому
-1 байт благодаря Martmists
-1 байт благодаря Джонатану Фреху}

lambda x:''.join(chr(int(`[+(l<'D')for l in b[::4]]`[1::3],2))for b in x.split())

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

Пробел, 123 байта

Видимое представление:

SSNNSSNSNSSSNSNSTNTSTTTSSSTSSSSSNTSSTSNSNTSSNSSSTSSTTSNTSSTNTSTNSSSTNTSSSNSSTNSSNSNSSNSTNTSTNTSTNTSTSSSNSNNNSSSNSNTTNSSNSNN

Необъяснимая программа:

    push  0
loop:
    dup
    push  0
    dup
    ichr
    get
    push  32
    sub
    dup
    jz    space
    push  38
    sub
    jz    fizz
    push  1
    add
fizz:
    push  0
    dup
    dup
    ichr
    ichr
    ichr
    add
    jmp   loop
space:
    swap
    pchr
    jmp   loop

В реализации нет ничего особенно странного, единственная настоящая игра в гольф заключается в некотором странном повторном использовании временных файлов, а также в том, что они не заботятся о неограниченном росте стека, чтобы уменьшить количество байтов.

Октава , 59 57 53 байта

@(s)['',bi2de(flip(reshape(s(65<s&s<71)<70,8,[]))')']

Это не работает на TIO, поскольку инструментарий связи не реализован. Он отлично работает, если вы копируете и вставляете его в Octave-online . Это даже не близко, чтобы работать код в MATLAB.

Удалось сохранить два байта, переставив матрицу после переворачивания, а не наоборот.

Объяснение:

@(s)             % Anonymous function that takes a string as input
    ['',<code>]  % Implicitly convert the result of <code> to its ASCII-characters

Давайте начнем с середины <code>:

s(65<s&s<71)      % Takes the elements of the input string that are between 66 and 70 (B and F)
                  % This gives a string FBBFFBBFBBBFFFBF...
s(65<s&s<71)<70   % Converts the resulting string into true and false, where F becomes false.
                  % Transformation: FBBFFB -> [0, 1, 1, 0, 0, 1]

Давайте назовем результирующий логический (двоичный) вектор для t.

reshape(t,8,[])       % Convert the list of 1 and 0 into a matrix with 8 rows, one for each bit
flip(reshape(t,8,[])) % Flip the matrix vertically, since bi2de reads the bits from the wrong end
flip(reshape(t,8,[]))' % Transpose it, so that we have 8 columns, and one row per character
bi2de(.....)'          % Convert the result decimal values and transpose it so that it's horizontal

Perl 5, 28 байт + 4 байта для флагов = 32 байта

Беги с флагами -040pE

$_=chr oct"0b".y/FB -z/01/dr

-040 устанавливает разделитель записей в пробел так, чтобы perl рассматривал каждую группу FizzBuzzes как отдельную строку, затем перебирал эти строки, изменяя F на 0, B на 1, удаляя все остальное, затем преобразовывая в двоичный файл и оттуда в ascii.

Желе , 9 байт

Ḳm€4=”BḄỌ

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

Ḳm€4=”BḄỌ  Main Link
Ḳ          Split on spaces
  €        Map
 m 4       Take every fourth letter (F and B)
    =”B    Check if each letter is equal to B (gives the binary representation)
       Ḅ   Binary -> Integer
        Ọ  Unord; gives chr(i)

-3 байта благодаря Эрику Аутгольферу

PHP, 67 байт

Ограничено до 8 букв

<?=hex2bin(dechex(bindec(strtr($argn,[Fizz=>0,Buzz=>1," "=>""]))));

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

PHP, 77 байт

foreach(explode(" ",strtr($argn,[Fizz=>0,Buzz=>1]))as$v)echo chr(bindec($v));

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

Brain-Flak , 107 байт

{(((((()()()()){}){}){})({}[{}])()())((){[()](<{}>)}{}<>)<>{(<{}{}{}{}>)<>({}({}){})<>}{}}<>{({}<>)<>}<>

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

+3 байта за -cфлаг.

объяснение

{                                        For each character in input:
 (((((()()()()){}){}){})({}[{}])()())    Push 32-n and 66-n
 ((){[()](<{}>)}{}<>)<>                  If character is B, push 1 on second stack.  Otherwise, push 0
 {                                       If character is not space:
  (<{}{}{}{}>)                           Burn 3 additional characters
  <>({}({}){})<>                         Multiply current byte by 2 and add previously pushed bit
 }                                       (otherwise, the pushed 0 becomes the new current byte)
 {}                                      Remove character from input
}
<>{({}<>)<>}<>                           Reverse stack for output

q / kdb +, 41 40 37 33 байта

Решение:

{10h$0b sv'66=vs[" ";x][;4*(!)8]}

Пример:

q){10h$0b sv'66=vs[" ";x][;4*(!)8]}"FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"
"hi!"

Объяснение:

Разбейте входную строку, " "чтобы получить отдельные списки FizzBuzz..., индексировать в каждом из этих списков по первому символу (то есть 0 4 8 ... 28). Возвращает логический список, определяемый тем, является ли каждый символ "B"(ASCII 66). Преобразуйте эти списки в базу 10, а затем приведите результат к строке.

{10h$0b sv'66=vs[" ";x][;4*til 8]} / ungolfed solution
{                                } / lambda function with x as implicit input
              vs[" ";x]            / split (vs) input (x) on space (" ")
                           til 8   / til 8, the range 0..7 inclusive
                         4*        / vectorised multiplication, 0 1 2 3 => 0 4 8 12
                       [;       ]  / index the 2nd level at these indices (0, 4, 8 ... 28)
           66=                     / 66 is ASCII B, 66="FBBFBFFF" -> 01101000b
     0b sv'                        / join (sv) each row back with 0b (converts from binary)
 10h$                              / cast to ASCII (0x686921 -> "hi!")

Haskell, 72 байта

(>>= \w->toEnum(foldl1((+).(2*))[mod(fromEnum c)5|c<-w,c<'a']):"").words

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

Как это работает

            words      -- split input string into words at spaces
(>>=      )            -- map the function to each word and flatten the resulting
                       -- list of strings into a single string
   \w->                -- for each word w
       [  |c<-w,c<'a'] -- take chars c that are less than 'a' (i.e. B and F)
     mod(fromEnum c)5  -- take ascii value of c modulus 5, i.e. convert to bit value
    foldl1((+).(2*))   -- convert list of bit to int
  toEnum(   ):""       -- convert ascii to char.  :"" forces toEnum to be of type String
                       -- now we have a list of single char strings, e.g. ["h","i","!"]        

JavaScript ES6 - 98 байт

слишком много байтов, но, по крайней мере, читабельно

Определяется как функция, это 98 байт

let s=>s.replace(/(F)|(B)|./g,(c,F,B)=>B?1:F?0:'').replace(/.{8}/g,v=>String.fromCharCode('0b'+v))

тест:

"FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"
.replace(/(F)|(B)|./g,(c,F,B)=>F?0:B?1:'').replace(/.{8}/g,v=>String.fromCharCode('0b'+v))

Объяснение:

/(F)|(B)|./

Сопоставляет буквы F и B и все остальное как группы

(c,F,B)=>F?0:B?1:''

является функцией, которая захватывает группы, возвращает 0 для F и 1 для B или ''

c символ соответствует
F и B теперь параметры!
3-й . группа не указана в качестве параметра

F и B undefinedсоответствуют 3-й группе,
B соответствуют undefinedгруппе F

Результирующая строка 0100 .. и т. Д.

нарезается ломтиками по 8 байт

.replace(/.{8}/g,v=>String.fromCharCode('0b'+v))

и обрабатывается как двоичная строка 0b

shortC , 35 байт

i;AW*@&3?*@&9||(i+=i+*s%5):Pi),*s++

Конверсии в этой программе:

• A - int main(int argc, char **argv){
• W - while(
• @ - argv
• P - putchar(
• Авто-вставить );}

Сильно основано на ответе Дверной ручки.

APL (Dyalog Classic) , 17 байтов

{82⎕DR'B'=⍵∩'BF'}

объяснение

           ⍵∩'BF'    cut, removes all but 'BF' from ⍵
       'B'=          equals 'B' turns it into binary stream   
 82⎕DR              converts into character stream

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

05AB1E , 15 байтов

#vy„FBÃS'BQ2βçJ

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

Google Sheets, 94 байта

=ArrayFormula(JOIN("",CHAR(BIN2DEC(SPLIT(SUBSTITUTE(SUBSTITUTE(A1,"Fizz",0),"Buzz",1)," ")))))

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

• Заменить Fizzс 0и Buzzс1
• Разделить результат на массив, используя пробел в качестве разделителя
• Преобразовать каждый элемент из двоичного в десятичное
• Замените каждый элемент его эквивалентом ASCII
• Присоединяйтесь к каждому элементу без разделителя

Java 8, 117 115 байт

s->{for(String x:s.split(" "))System.out.print((char)Long.parseLong(x.replace("Fizz","0").replace("Buzz","1"),2));}

Я сомневаюсь, что вы можете сделать много необычных замен регулярных выражений в Java, как и большинство других ответов, главным образом потому, что вы ничего не можете сделать с захваченными группами захвата в Java-регулярных выражениях .. (т. Е. "$1".charAt(...)Или "$1".replace(...)невозможно, например.)

Объяснение:

Попробуй это здесь.

s->{                          // Method with String parameter and no return-type
  for(String x:s.split(" "))  //  Loop over the input split by spaces:
    System.out.print(         //   Print:
     (char)                   //    Each character
     Long.parseLong(          //    after we've converted each binary-String to a long
      x.replace("Fizz","0").replace("Buzz","1")
                              //    after we've replaced the Fizz/Buzz to 0/1
     ,2));
}                             // End of method

J , 20 байт

a.{~_8#.\2-.~'FB'i.]

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