Wprowadzenie

Nie wiem szczególnie , skąd wziął się ten trend. To może być tylko mem lub coś takiego, ale jest dość popularny.

Wyzwanie

Twoim dzisiejszym zadaniem jest konwersja Fizz Buzz na odpowiednio binarne (0, 1) i konwersja tego binarnego na tekst. Całkiem standardowe rzeczy.

Jak to działa?

FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz można przetłumaczyć na 01101000 01101001, a to znaczy „cześć”

Ograniczenia

• Dane wejściowe to Fizz Buzz z binarnego punktu widzenia (patrz przykłady poniżej).
• Dane wyjściowe muszą być tekstem.
• Możesz założyć, że wejście FizzBuzz jest prawidłowe.
• To jest golf golfowy , najkrótsze bajty wygrywają.

Wkład

FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz

Wydajność

"cześć!"

C, 59 bajtów

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

Magiczne liczby, magiczne liczby wszędzie!

(Również C jest krótszy niż Python, JS, PHP i Ruby? Niespotykane!)

Jest to funkcja, która pobiera ciąg jako dane wejściowe i wyjściowe do STDOUT.

Przewodnik

Podstawowa struktura to:

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

Tutaj „rzeczy w środku” to wiązka kodu, po ,*s++której operator przecinka zwraca tylko wartość drugiego argumentu. Dlatego też przejdzie przez ciąg i ustawi *skażdy znak, w tym końcowy bajt NUL (ponieważ postfix ++zwraca poprzednią wartość) przed wyjściem.

Rzućmy okiem na resztę:

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

Odrywając trójskładnikowe i zwarciowe ||, można to rozszerzyć do

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

Skąd pochodzą te magiczne liczby? Oto reprezentacje binarne wszystkich zaangażowanych postaci:

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

Najpierw musimy oddzielić spację i NUL od reszty postaci. Sposób działania tego algorytmu utrzymuje akumulator o numerze „bieżącym” i wypisuje go, gdy tylko dojdzie do spacji lub końca łańcucha (tj '\0'.). Zauważając to ' 'i '\0'jesteśmy jedynymi znakami, które nie mają ustawionego żadnego z dwóch najmniej znaczących bitów, możemy bitowo ORAZ znak za pomocą, 0b11aby uzyskać zero, jeśli znak jest spacją lub NUL i w przeciwnym razie jest niezerowy.

Kopiąc głębiej, w pierwszej gałęzi „jeśli” mamy teraz jedną z postaci FBizu. Zdecydowałem się tylko zaktualizować akumulator na Fsi Bs, więc potrzebowałem jakiegoś sposobu, aby odfiltrować izus. Dogodnie Fi Boba mają tylko drugi, trzeci lub siódmy najmniej znaczący zestaw bitów, a wszystkie pozostałe liczby mają co najmniej jeden inny zestaw bitów. W rzeczywistości wszystkie mają pierwszy lub czwarty najmniej znaczący bit. Stąd możemy bitowo ORAZ z 0b00001001, która wynosi 9, co da 0 dla Fi, w Bprzeciwnym razie, zero.

Po ustaleniu, że mamy Flub B, możemy zmapować je odpowiednio na 0i 1, biorąc ich moduł 5, ponieważ Fjest 70i Bjest 66. Następnie fragment kodu

i += i + *s % 5;

to po prostu golfowy sposób na powiedzenie

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

co można również wyrazić jako

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

który wstawia nowy bit w co najmniej znaczącej pozycji i przesuwa wszystko inne o 1.

"Ale poczekaj!" możesz protestować. „Po wydrukowaniu i, kiedy w ogóle resetuje się do 0?” Cóż, putcharrzuca swój argument na an unsigned char, który akurat ma 8 bitów. Oznacza to, że wszystko po 8. najmniej znaczącym bicie (tj. Śmieci z poprzednich iteracji) jest wyrzucane i nie musimy się tym martwić.

Dzięki @ETHproductions za sugerowanie zastąpić 57z 9, oszczędzając bajt!

Galaretka , 9 bajtów

Ḳm€4O%5ḄỌ

Wypróbuj online!

Bash + coreutils, 61 50 bajtów

(-11 bajtów dzięki Klamce !)

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

Wypróbuj online!

Python 3 , 169 101 93 91 85 81 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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 bajtów

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 bajtów

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

Wypróbuj online!

Zaoszczędzono 2 bajty dzięki @Shaggy i 2 bajty dzięki @ETHproductions

Wyjaśnienie

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

Rubinowy, 65 63 60 bajtów

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

Jest to anonimowy proc, który pobiera dane wejściowe i podaje dane wyjściowe jako ciąg znaków.

->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 bajtów

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

• 4 bajty zaoszczędzone dzięki ETHproductions .

Spróbuj

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 bajtów

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

Zamienia „F” i „B” na wejściu odpowiednio na 0 i 1 oraz usuwa inne znaki. Następnie używa packfunkcji perla, aby przekształcić ten ciąg bitów w znaki ASCII.

Python 2 , 90 83 82 81 bajtów

^{-1 bajt dzięki totalnie ludzkiemu
-1 bajt dzięki Martmistom
-1 bajt dzięki Jonathanowi Frechowi}

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

Wypróbuj online!

Biała spacja, 123 bajty

Widoczne przedstawienie:

SSNNSSNSNSSSNSNSTNTSTTTSSSTSSSSSNTSSTSNSNTSSNSSSTSSTTSNTSSTNTSTNSSSTNTSSSNSSTNSSNSNSSNSTNTSTNTSTNTSTSSSNSNNNSSSNSNTTNSSNSNN

Nieobrobiony program:

    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

W implementacji nie ma nic szczególnie dziwnego, jedyne prawdziwe gra w golfa polega na jakimś dziwnym ponownym wykorzystaniu tymczasowości, a także nie dbanie o nieograniczony wzrost stosu, aby przesunąć więcej bajtów.

Oktawa , 59 57 53 bajtów

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

To nie działa w TIO, ponieważ zestaw narzędzi komunikacyjnych nie jest zaimplementowany. Działa dobrze, jeśli skopiujesz i wkleisz go do Octave-online . Nie jest nawet blisko działającego kodu w MATLAB.

Udało się zaoszczędzić dwa bajty, transponując matrycę po odwróceniu, zamiast na odwrót.

Wyjaśnienie:

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

Zacznijmy w środku <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]

Nazwijmy wynikowy wektor boolowski (binarny) dla 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 bajtów + 4 bajty dla flag = 32 bajty

Uruchom z flagami -040pE

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

-040 ustawia separator rekordów na spację, dzięki czemu perl widzi każdą grupę FizzBuzzów jako osobną linię, a następnie zapętla te linie, zmieniając F na 0, B na 1, usuwając wszystko inne, a następnie konwertując na binarne, a stamtąd na ascii.

Galaretka , 9 bajtów

Ḳm€4=”BḄỌ

Wypróbuj online!

Ḳ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 bajty dzięki Erikowi Outgolferowi

PHP, 67 bajtów

Ograniczony do 8 liter

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

Wypróbuj online!

PHP, 77 bajtów

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

Wypróbuj online!

Brain-Flak , 107 bajtów

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

Wypróbuj online!

+3 bajty dla -cflagi.

Wyjaśnienie

{                                        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 bajtów

Rozwiązanie:

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

Przykład:

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

Wyjaśnienie:

Podziel ciąg wejściowy na, " "aby uzyskać odrębne listy FizzBuzz..., indeks na każdej z tych list przy pierwszym znaku (tj 0 4 8 ... 28.). Zwraca listę boolowską określoną przez to, czy każdy znak to "B"(ASCII 66). Konwertuj te listy na bazę 10, a następnie rzutuj wynik na ciąg.

{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 bajty

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

Wypróbuj online!

Jak to działa

            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 bajtów

za dużo bajtów, ale przynajmniej czytelne

Zdefiniowany jako funkcja ma 98 bajtów

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

test:

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

Wyjaśnienie:

/(F)|(B)|./

Dopasowuje litery F i B i wszystko inne jako Grupy

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

to funkcja, która przechwytuje grupy, zwraca 0 dla F i 1 dla B lub ''

c jest znakiem dopasowanym
F i B są teraz parametrami!
3 . grupa jest odrzucana jako parametr

F i B występują, undefinedgdy dopasowana jest trzecia grupa.
B występuje, undefinedgdy dopasowana jest grupa F.

Wynikowy ciąg 0100 .. itd

jest pocięty na plasterki po 8 bajtów

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

i przetwarzany jako ciąg binarny 0b

shortC , 35 bajtów

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

Konwersje w tym programie:

• A - int main(int argc, char **argv){
• W - while(
• @ - argv
• P - putchar(
• Automatyczne wstawianie );}

Mocno oparty na odpowiedzi Doorknoba.

APL (Dyalog Classic) , 17 bajtów

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

Wyjaśnienie

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

Wypróbuj online!

05AB1E , 15 bajtów

#vy„FBÃS'BQ2βçJ

Wypróbuj online!

Arkusze Google, 94 bajty

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

Nie znam binarnego FizzBuzz, ale wygląda na to, że są one rozdzielone spacjami, więc ta formuła opiera się na tym. Logika jest dość prosta:

• Wymień Fizzsię 0i Buzzze1
• Podziel wynik na tablicę, używając spacji jako separatora
• Konwertuj każdy element z binarnego na dziesiętny
• Zastąp każdy element jego odpowiednikiem ASCII
• Dołącz do każdego elementu bez ogranicznika

Java 8, 117 115 bajtów

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

Wątpię, można zrobić wiele zamienników fantazyjne regex w Javie jak większość innych odpowiedzi, głównie dlatego, że nie może nic z przechwyconych przechwytywania grup w Java-regexes zrobić .. (Ie "$1".charAt(...)lub"$1".replace(...) nie są możliwe.)

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów

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

Wypróbuj online!