Einführung

Ich weiß nicht besonders wissen , wo die Fizz Buzz Trend herkam. Es ist vielleicht nur ein Mem oder so, aber es ist etwas populär.

Herausforderung

Ihre Aufgabe heute ist es, Fizz Buzz in eine Binärdatei (0, 1) umzuwandeln und diese Binärdatei in Text umzuwandeln. Ziemlich normales Zeug.

Wie funktioniert das?

FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz würde in 01101000 01101001 übersetzen, dann würde das in "hi" übersetzen

Einschränkungen

• Die Eingabe ist in binärer Hinsicht Fizz Buzz (siehe Beispiele unten).
• Die Ausgabe muss Text sein.
• Sie können davon ausgehen, dass der FizzBuzz-Eingang richtig ist.
• Das ist Code-Golf , der Gewinn mit den kürzesten Bytes.

Eingang

FizzBuzzBuzzFizzBuzzFizzFizzFizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz

Ausgabe

"Hallo!"

C 59 Bytes

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

Magische Zahlen, magische Zahlen überall!

(Auch C kürzer als Python, JS, PHP und Ruby? Unbekannt!)

Dies ist eine Funktion, die eine Zeichenfolge als Eingabe und Ausgabe für STDOUT verwendet.

Komplettlösung

Die Grundstruktur ist:

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

Hier ist "stuff inside" eine Reihe von Code, gefolgt von einem ,*s++Kommaoperator, der nur den Wert seines zweiten Arguments zurückgibt. Daher durchläuft dies die Zeichenfolge und setzt sie *sauf jedes Zeichen, einschließlich des nachfolgenden NUL-Bytes (da postfix ++den vorherigen Wert zurückgibt), bevor es beendet wird.

Werfen wir einen Blick auf den Rest:

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

Das Abschälen des Ternär- und Kurzschlusses ||kann erweitert werden

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

Woher kommen diese magischen Zahlen? Hier sind die binären Darstellungen aller beteiligten Zeichen:

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

Zuerst müssen wir Leerzeichen und NUL vom Rest der Zeichen trennen. So wie dieser Algorithmus funktioniert, speichert er einen Akkumulator der "aktuellen" Zahl und gibt ihn immer dann aus, wenn er ein Leerzeichen oder das Ende der Zeichenfolge erreicht (dh '\0'). Wenn wir das bemerken ' 'und '\0'die einzigen Zeichen sind, bei denen keines der beiden niedrigstwertigen Bits gesetzt ist, können wir das Zeichen bitweise UND mit 0b11Null verknüpfen, wenn das Zeichen ein Leerzeichen oder NUL ist und ansonsten ungleich Null.

Wenn wir tiefer graben, haben wir im ersten "Wenn" -Zweig jetzt einen Charakter, von dem einer ist FBizu. Ich entschied mich nur, den Akku auf Fs und Bs zu aktualisieren , also brauchte ich eine Möglichkeit, die izus herauszufiltern . Praktischerweise Fund Bbeide haben nur das zweite, dritte oder siebtniedrigste gesetzte Bit, und alle anderen Zahlen haben mindestens ein anderes gesetztes Bit. Tatsächlich haben sie alle entweder das erste oder das viertniedrigstwertige Bit. Daher können wir bitweise UND mit 0b00001001, was 9 ist, was andernfalls 0 für Fund Bund ungleich Null ergibt .

Nachdem wir festgestellt haben , dass wir ein Foder Bkönnen wir sie kartieren 0und die 1jeweils durch ihre Modul 5 zu nehmen, weil Fist 70und Bist 66. Dann das Snippet

i += i + *s % 5;

ist nur eine golferische Art zu sagen

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

was auch ausgedrückt werden kann als

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

Dadurch wird das neue Bit an der niedrigstwertigen Position eingefügt und alles andere um 1 verschoben.

"Aber warte!" du könntest protestieren. " iWann wird der Wert nach dem Drucken wieder auf 0 zurückgesetzt?" Nun, putcharwirft sein Argument auf ein unsigned char, das gerade mal 8 Bit groß ist. Das bedeutet, dass alles, was nach dem 8. Bit mit der geringsten Signifikanz liegt (dh der Müll aus früheren Iterationen), weggeworfen wird, und wir müssen uns keine Sorgen machen.

Dank @ETHproductions für das Vorschlagen ersetzen 57mit 9, Speichern eines Byte!

Gelee , 9 Bytes

Ḳm€4O%5ḄỌ

Probieren Sie es online!

Bash + Coreutils, 61 50 Bytes

(-11 Bytes dank Doorknob !)

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

Probieren Sie es online!

Python 3 , 169 101 93 91 85 81 Bytes

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

Probieren Sie es online!

Erläuterung:

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 bis 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 Bytes

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

Probieren Sie es online!

2 Bytes dank @Shaggy & 2 Bytes dank @ETHproductions eingespart

Erläuterung

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 Bytes

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

Dies ist eine anonyme Prozedur, die Eingaben entgegennimmt und Ausgaben als Zeichenfolge ausgibt.

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

• Dank ETHproductions 4 Bytes gespart .

Versuch es

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 Bytes

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

Ersetzt 'F' und 'B' in der Eingabe durch 0 bzw. 1 und löscht die anderen Zeichen. Anschließend wird packdiese Bitfolge mithilfe der Perl- Funktion in ASCII-Zeichen umgewandelt.

Python 2 , 90 83 82 81 Bytes

^{-1 Byte dank totalhuman
-1 Byte dank Martmists
-1 Byte dank Jonathan Frech}

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

Probieren Sie es online!

Leerzeichen, 123 Bytes

Sichtbare Darstellung:

SSNNSSNSNSSSNSNSTNTSTTTSSSTSSSSSNTSSTSNSNTSSNSSSTSSTTSNTSSTNTSTNSSSTNTSSSNSSTNSSNSNSSNSTNTSTNTSTNTSTSSSNSNNNSSSNSNTTNSSNSNN

Unverdecktes Programm:

    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

Die Implementierung ist nicht sonderlich merkwürdig. Das einzig wahre Golfspiel besteht in einer merkwürdigen Wiederverwendung von Provisorien, und es ist nicht wichtig, dass das unbegrenzte Stapelwachstum dazu beiträgt, weitere Bytes zu überfliegen.

Oktave , 59 57 53 Bytes

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

Dies funktioniert bei TIO nicht, da die Kommunikations-Toolbox nicht implementiert ist. Es funktioniert einwandfrei, wenn Sie es in Octave-online kopieren und einfügen . Es ist noch nicht einmal nah dran, in MATLAB mit Code zu arbeiten.

Es gelang, zwei Bytes zu sparen, indem die Matrix nach dem Umdrehen transponiert wurde, anstatt umgekehrt.

Erläuterung:

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

Beginnen wir in der Mitte von <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]

Nennen wir den resultierenden booleschen (binären) Vektor für 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 Bytes + 4 Bytes für Flags = 32 Bytes

Laufen Sie mit den Fahnen -040pE

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

-040 Setzt das Datensatztrennzeichen auf ein Leerzeichen, sodass Perl jede Gruppe von FizzBuzzes als separate Zeile ansieht, diese Zeilen dann in einer Schleife durchläuft, F in 0, B in 1 ändert, alles andere löscht und dann in binär und von dort in ASCII konvertiert.

Gelee , 9 Bytes

Ḳm€4=”BḄỌ

Probieren Sie es 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 Bytes dank Erik dem Outgolfer

PHP, 67 Bytes

Limitiert auf 8 Buchstaben

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

Probieren Sie es online!

PHP, 77 Bytes

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

Probieren Sie es online!

Brain-Flak , 107 Bytes

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

Probieren Sie es online!

+3 Bytes für das -cFlag.

Erläuterung

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

Lösung:

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

Beispiel:

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

Erläuterung:

Teilen Sie die Eingabezeichenfolge auf " ", um FizzBuzz...beim ersten Zeichen (dh 0 4 8 ... 28) eindeutige Listen von , index in jede dieser Listen zu geben . Gibt eine boolesche Liste zurück, die davon bestimmt wird, ob jedes Zeichen "B"(ASCII 66) ist. Konvertieren Sie diese Listen zur Basis 10 und wandeln Sie das Ergebnis in eine Zeichenfolge um.

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

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

Probieren Sie es online!

Wie es funktioniert

            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 Bytes

zu viele Bytes, aber zumindest lesbar

Als Funktion definiert sind es 98 Bytes

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

Prüfung:

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

Erläuterung:

/(F)|(B)|./

Entspricht den Buchstaben F und B sowie allen anderen Buchstaben als Gruppen

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

ist eine Funktion, die die Gruppen erfasst, 0 für F und 1 für B zurückgibt oder ''

c ist das Zeichen, das mit
F und B übereinstimmt. Jetzt sind es Parameter!
der 3 .. Gruppe wird als Parameter ausgelassen

F und B sind, undefinedwenn die 3. Gruppe übereinstimmt.
B ist, undefinedwenn die Gruppe F übereinstimmt

Die resultierende 0100 .. etc Zeichenfolge

wird in Scheiben von 8 Bytes geschnitten

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

und verarbeitet als 0b binäre Zeichenfolge

shortC , 35 bytes

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

Conversions in diesem Programm:

• A - int main(int argc, char **argv){
• W - while(
• @ - argv
• P - putchar(
• Automatisch eingefügt );}

Schwer basiert auf der Antwort von Doorknob.

APL (Dyalog Classic) , 17 Byte

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

Erläuterung

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

Probieren Sie es online!

05AB1E , 15 Bytes

#vy„FBÃS'BQ2βçJ

Probieren Sie es online!

Google Sheets, 94 Bytes

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

Ich bin nicht mit FizzBuzz-Binärdateien vertraut, aber es scheint, dass sie durch Leerzeichen abgegrenzt sind, sodass sich diese Formel darauf stützt. Die Logik ist ziemlich einfach:

• Ersetzen Sie Fizzmit 0und Buzzmit1
• Teilen Sie das Ergebnis in ein Array auf, indem Sie ein Leerzeichen als Trennzeichen verwenden
• Konvertieren Sie jedes Element von binär in dezimal
• Ersetzen Sie jedes Element durch sein ASCII-Äquivalent
• Verbinden Sie jedes Element ohne Begrenzer

Java 8, 117 115 Bytes

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

Ich bezweifle , können Sie wie die meisten anderen Antworten in Java viele der Phantasie regex Ersatz zu tun, vor allem , weil man nichts mit den erfassten Capture-Gruppen in Java-Regexes tun können .. (Ie "$1".charAt(...)oder "$1".replace(...)nicht möglich sind zum Beispiel.)

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

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

Probieren Sie es online!