Giới thiệu

Tôi đặc biệt không biết xu hướng buzz fizz đến từ đâu. Nó có thể chỉ là một meme hoặc một cái gì đó, nhưng nó có phần phổ biến.

Thử thách

Công việc của bạn hôm nay là chuyển đổi Fizz Buzz thành nhị phân (0, 1) tương ứng và chuyển đổi nhị phân đó thành văn bản. Công cụ khá chuẩn.

Làm thế nào mà làm việc?

FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz sẽ dịch thành 01101000 01101001 sau đó sẽ dịch thành "hi"

Những ràng buộc

• Đầu vào là Fizz Buzz theo quan điểm nhị phân (xem ví dụ bên dưới.)
• Đầu ra phải là văn bản.
• Bạn có thể giả sử đầu vào FizzBuzz là đúng.
• Đây là mã golf , byte ngắn nhất giành chiến thắng.

Đầu vào

FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz

Đầu ra

"Chào!"

C, 59 byte

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

Số ma thuật, số ma thuật ở khắp mọi nơi!

(Ngoài ra, C ngắn hơn Python, JS, PHP và Ruby? Chưa từng thấy!)

Đây là một hàm lấy một chuỗi làm đầu vào và đầu ra cho STDOUT.

Hướng dẫn

Cấu trúc cơ bản là:

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

Ở đây, "nội dung bên trong" là một loạt các mã theo sau ,*s++, trong đó toán tử dấu phẩy chỉ trả về giá trị của đối số thứ hai của nó. Do đó, điều này sẽ chạy qua chuỗi và được đặt *sthành mọi ký tự, bao gồm byte NUL trailing (vì postfix ++trả về giá trị trước đó), trước khi thoát.

Hãy xem phần còn lại:

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

Lột bỏ ternary và ngắn mạch ||, điều này có thể được mở rộng để

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

Những con số ma thuật này đến từ đâu? Dưới đây là các biểu diễn nhị phân của tất cả các nhân vật liên quan:

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

Đầu tiên, chúng ta cần tách không gian và NUL khỏi các nhân vật còn lại. Cách thuật toán này hoạt động, nó giữ một bộ tích lũy của số "hiện tại" và in nó bất cứ khi nào nó đạt đến một khoảng trắng hoặc cuối chuỗi (tức là '\0'). Bằng cách nhận thấy rằng ' 'và '\0'là các ký tự duy nhất không có bất kỳ bit nào trong hai bit có ý nghĩa nhỏ nhất, chúng ta có thể bit bit VÀ ký tự bằng 0b110 nếu ký tự là khoảng trắng hoặc NUL và khác không.

Đào sâu hơn, trong nhánh "nếu" đầu tiên, bây giờ chúng ta có một nhân vật là một trong số đó FBizu. Tôi đã chọn chỉ cập nhật bộ tích lũy trên Fs và Bs, vì vậy tôi cần một số cách để lọc ra izus. Thuận tiện Fvà Bcả hai chỉ có các bit quan trọng thứ hai, thứ ba hoặc thứ bảy, và tất cả các số khác có ít nhất một bit khác được đặt. Trong thực tế, tất cả chúng đều có bit đầu tiên hoặc thứ tư ít quan trọng nhất. Do đó, chúng ta có thể Bitwise và với 0b00001001, đó là 9, mà sẽ mang lại 0 cho Fvà Bvà khác không khác.

Khi chúng tôi đã xác định rằng chúng tôi có một Fhoặc B, chúng tôi có thể ánh xạ chúng tới 0và 1tương ứng bằng cách lấy mô đun 5 của chúng, bởi vì Fnó đã 70và Bđang tồn tại 66. Sau đó là đoạn trích

i += i + *s % 5;

chỉ là một cách nói golf

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

cũng có thể được thể hiện như

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

trong đó chèn bit mới vào vị trí ít quan trọng nhất và dịch chuyển mọi thứ khác trên 1.

"Nhưng đợi đã!" bạn có thể phản đối "Sau khi bạn in i, khi nào nó được đặt lại về 0?" Chà, putcharđưa đối số của nó thành một unsigned char, có kích thước tương đương 8 bit. Điều đó có nghĩa là mọi thứ vượt qua bit thứ 8 ít nhất (nghĩa là rác từ các lần lặp trước) bị vứt đi và chúng ta không cần phải lo lắng về điều đó.

Cảm ơn @ETHproductions đã đề xuất thay thế 57bằng 9, tiết kiệm một byte!

Thạch , 9 byte

Ḳm€4O%5ḄỌ

Hãy thử trực tuyến!

Bash + coreutils, 61 50 byte

(-11 byte nhờ Doorknob !)

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

Hãy thử trực tuyến!

Python 3 , 169 101 93 91 85 81 byte

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

Hãy thử trực tuyến!

Giải trình:

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 byte

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 byte

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

Hãy thử trực tuyến!

Đã lưu 2 byte nhờ @Shaggy & 2 byte nhờ @ETHproductions

Giải trình

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

Ruby, 65 63 60 byte

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

Đây là một Proc ẩn danh nhận đầu vào và cung cấp đầu ra dưới dạng một chuỗi.

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

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

• 4 byte được lưu nhờ vào ETHproductions .

Thử nó

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 byte

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

Thay thế 'F' và 'B' trong đầu vào bằng 0 và 1 tương ứng và xóa các ký tự khác. Sau đó, nó sử dụng packchức năng của perl để biến chuỗi bit này thành các ký tự ASCII.

Python 2 , 90 83 82 81 byte

^{-1 byte nhờ hoàn toàn
-1 byte nhờ Martmists
-1 byte nhờ Jonathan Frech}

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

Hãy thử trực tuyến!

Khoảng trắng, 123 byte

Đại diện hữu hình:

SSNNSSNSNSSSNSNSTNTSTTTSSSTSSSSSNTSSTSNSNTSSNSSSTSSTTSNTSSTNTSTNSSSTNTSSSNSSTNSSNSNSSNSTNTSTNTSTNTSTSSSNSNNNSSSNSNTTNSSNSNN

Chương trình không tập trung:

    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

Không có gì đặc biệt kỳ lạ về việc thực hiện, việc chơi golf thực sự duy nhất là trong một số lần sử dụng lại thời gian kỳ lạ cũng như không quan tâm đến sự tăng trưởng ngăn xếp không bị ràng buộc để lướt qua một số byte.

Octave , 59 57 53 byte

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

Điều này không hoạt động trên TIO, vì hộp công cụ truyền thông không được triển khai. Nó hoạt động tốt nếu bạn sao chép-dán nó vào Octave-online . Nó thậm chí không gần với mã làm việc trong MATLAB.

Quản lý để lưu hai byte bằng cách hoán vị ma trận sau khi lật nó, thay vì cách khác.

Giải trình:

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

Hãy bắt đầu ở giữa <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]

Chúng ta hãy gọi vectơ boolean (nhị phân) kết quả cho 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 byte + 4 byte cho flags = 32 byte

Chạy với cờ -040pE

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

-040 đặt dấu tách bản ghi thành một khoảng trắng để perl thấy mỗi nhóm FizzBuzzes là một dòng riêng biệt, sau đó lặp lại các dòng đó, thay đổi F thành 0, B thành 1, xóa mọi thứ khác, sau đó chuyển đổi thành nhị phân và từ đó thành ascii.

Thạch , 9 byte

Ḳm€4=”BḄỌ

Hãy thử trực tuyến!

Ḳ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 byte nhờ Erik the Outgolfer

PHP, 67 byte

Giới hạn 8 chữ cái

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

Hãy thử trực tuyến!

PHP, 77 byte

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

Hãy thử trực tuyến!

Brain-Flak , 107 byte

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

Hãy thử trực tuyến!

+3 byte cho -ccờ.

Giải trình

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

Dung dịch:

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

Thí dụ:

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

Giải trình:

Tách chuỗi đầu vào " "để đưa ra các danh sách FizzBuzz..., chỉ mục riêng biệt cho từng danh sách này ở ký tự đầu tiên (nghĩa là 0 4 8 ... 28). Trả về danh sách boolean được xác định bởi mỗi ký tự là "B"(ASCII 66). Chuyển đổi các danh sách này thành cơ sở 10, và sau đó truyền kết quả thành chuỗi.

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

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

            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 byte

quá nhiều byte, nhưng ít nhất có thể đọc được

Được định nghĩa là hàm, nó là 98 byte

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

kiểm tra:

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

Giải trình:

/(F)|(B)|./

Khớp các chữ cái F và B và mọi thứ khác dưới dạng Nhóm

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

là Hàm bắt giữ các nhóm, trả về 0 cho F và 1 cho B hoặc ''

c là ký tự khớp với
F và B bây giờ là Tham số!
thứ 3 . nhóm được coi là tham số

F và B là undefinedkhi nhóm thứ 3 được khớp
B là undefinedkhi nhóm F được khớp

Chuỗi kết quả 0100 .. vv

được cắt thành lát 8 byte

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

và được xử lý dưới dạng chuỗi nhị phân 0b

shortC , 35 byte

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

Chuyển đổi trong chương trình này:

• A - int main(int argc, char **argv){
• W - while(
• @ - argv
• P - putchar(
• Tự động chèn );}

Dựa vào câu trả lời của Doorknob.

APL (Dyalog Classic) , 17 byte

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

Giải trình

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

Hãy thử trực tuyến!

05AB1E , 15 byte

#vy„FBÃS'BQ2βçJ

Hãy thử trực tuyến!

Google Sheets, 94 byte

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

Tôi không quen thuộc với nhị phân FizzBuzz nhưng có vẻ như chúng được phân định bằng các khoảng trắng nên công thức này dựa vào đó. Logic khá đơn giản:

• Thay thế Fizzbằng 0và Buzzbằng1
• Chia kết quả thành một mảng bằng cách sử dụng khoảng trắng làm dấu phân cách
• Chuyển đổi từng phần tử từ nhị phân sang thập phân
• Thay thế từng phần tử bằng tương đương ASCII của nó
• Tham gia mỗi yếu tố mà không có dấu phân cách

Java 8, 117 115 byte

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

Tôi nghi ngờ bạn có thể thực hiện nhiều thay thế regex ưa thích trong Java như hầu hết các câu trả lời khác, chủ yếu là vì bạn không thể làm gì với các nhóm bắt giữ trong Java-regexes .. ( ví dụ: không thể "$1".charAt(...)hoặc "$1".replace(...)không thể.)

Giải trình:

Hãy thử nó ở đây.

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 byte

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

Hãy thử trực tuyến!