introduction

Je ne sais pas particulièrement d' où vient la tendance du fizz buzz. Ce pourrait être juste un mème ou quelque chose, mais il est quelque peu populaire.

Défi

Votre travail consiste aujourd'hui à convertir Fizz Buzz en binaire (0, 1) respectivement, et à convertir ce binaire en texte. Des trucs assez standard.

Comment ça marche?

FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz se traduirait par 01101000 01101001 puis cela se traduirait par "salut"

Contraintes

• L'entrée est Fizz Buzz d'un point de vue binaire (voir les exemples ci-dessous.)
• La sortie doit être du texte.
• Vous pouvez supposer que l'entrée FizzBuzz est correcte.
• C'est le code-golf , la plus courte victoire en octets.

Contribution

FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz

Sortie

"salut!"

C, 59 octets

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

Des nombres magiques, des nombres magiques partout!

(De plus, C plus court que Python, JS, PHP et Ruby? Du jamais vu!)

Il s'agit d'une fonction qui prend une chaîne en entrée et sort vers STDOUT.

Procédure pas à pas

La structure de base est:

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

Ici, le "stuff inside" est un tas de code suivi de ,*s++, où l'opérateur virgule ne renvoie que la valeur de son deuxième argument. Par conséquent, cela parcourra la chaîne et sera défini *ssur chaque caractère, y compris l'octet NUL de fin (puisque postfix ++renvoie la valeur précédente), avant de quitter.

Jetons un coup d'œil au reste:

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

Décoller le ternaire et les courts-circuits ||, cela peut être étendu à

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

D'où viennent ces nombres magiques? Voici les représentations binaires de tous les personnages impliqués:

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

Tout d'abord, nous devons séparer l'espace et NUL du reste des caractères. La façon dont cet algorithme fonctionne, il conserve un accumulateur du nombre "courant", et l'imprime chaque fois qu'il atteint un espace ou la fin de la chaîne (ie '\0'). En remarquant cela ' 'et '\0'étant les seuls caractères à n'avoir aucun des deux bits les moins significatifs définis, nous pouvons bit par bit ET le caractère avec 0b11pour obtenir zéro si le caractère est un espace ou NUL et non nul sinon.

En creusant plus profondément, dans la première branche "if", nous avons maintenant un personnage qui en fait partie FBizu. J'ai choisi uniquement de mettre à jour l'accumulateur sur Fs et Bs, donc j'avais besoin d'un moyen de filtrer les izus. Idéalement, Fet les Bdeux n'ont que le deuxième, le troisième ou le septième ensemble de bits de poids faible, et tous les autres nombres ont au moins un autre ensemble de bits. En fait, ils ont tous le premier ou le quatrième bit le moins significatif. Par conséquent, nous pouvons binaire ET avec 0b00001001, qui est 9, ce qui donnera 0 pour Fet Bet non nul sinon.

Une fois que nous avons déterminé que nous avons un Fou B, nous pouvons les mapper à 0et 1respectivement en prenant leur module 5, parce que Fest 70et Best 66. Puis l'extrait

i += i + *s % 5;

est juste une façon golfique de dire

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

qui peut également être exprimé comme

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

qui insère le nouveau bit à la position la moins significative et décale tout le reste sur 1.

"Mais attendez!" vous pourriez protester. "Après avoir imprimé i, quand est-il jamais remis à zéro?" Eh bien, putcharconvertit son argument en un unsigned char, qui se trouve être 8 bits. Cela signifie que tout ce qui dépasse le 8e bit le moins significatif (c'est-à-dire la jonque des itérations précédentes) est jeté, et nous n'avons pas à nous en soucier.

Merci à @ETHproductions d' avoir proposé de remplacer 57par 9, d'économiser un octet!

Gelée , 9 octets

Ḳm€4O%5ḄỌ

Essayez-le en ligne!

Bash + coreutils, 61 50 octets

(-11 octets grâce à Doorknob !)

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

Essayez-le en ligne!

Python 3 , 169 101 93 91 85 81 octets

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

Essayez-le en ligne!

Explication:

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 octets

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 octets

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

Essayez-le en ligne!

2 octets enregistrés grâce à @Shaggy et 2 octets grâce à @ETHproductions

Explication

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

Rubis, 65 63 60 octets

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

Il s'agit d'un proc anonyme qui prend l'entrée et donne la sortie sous forme de chaîne.

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

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

• 4 octets économisés grâce à ETHproductions .

Essayez-le

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 octets

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

Remplace «F» et «B» dans l'entrée par 0 et 1 respectivement et supprime les autres caractères. Il utilise ensuite la packfonction de perl pour transformer cette chaîne de bits en caractères ASCII.

Python 2 , 90 83 82 81 octets

^{-1 octet grâce à totalement humain
-1 octet grâce aux Martmistes
-1 octet grâce à Jonathan Frech}

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

Essayez-le en ligne!

Espace, 123 octets

Représentation visible:

SSNNSSNSNSSSNSNSTNTSTTTSSSTSSSSSNTSSTSNSNTSSNSSSTSSTTSNTSSTNTSTNSSSTNTSSSNSSTNSSNSNSSNSTNTSTNTSTNTSTSSSNSNNNSSSNSNTTNSSNSNN

Programme non obscurci:

    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

L'implémentation n'a rien de particulièrement étrange, le seul vrai golf est dans une étrange réutilisation des temporaires ainsi que de ne pas se soucier de la croissance illimitée de la pile pour parcourir encore plus d'octets.

Octave , 59 57 53 octets

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

Cela ne fonctionne pas sur TIO, car la boîte à outils de communication n'est pas implémentée. Cela fonctionne très bien si vous le copiez-collez sur Octave-online . Ce n'est même pas près de fonctionner du code dans MATLAB.

Géré pour enregistrer deux octets en transposant la matrice après l'avoir retournée, au lieu de l'inverse.

Explication:

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

Commençons au milieu de <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]

Appelons le vecteur booléen (binaire) résultant pour 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 octets + 4 octets pour les indicateurs = 32 octets

Courez avec les drapeaux -040pE

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

-040 définit le séparateur d'enregistrement sur un espace de sorte que perl voit chaque groupe de FizzBuzz comme une ligne distincte, puis passe en boucle sur ces lignes, change F à 0, B à 1, supprime tout le reste, puis convertit en binaire et de là en ascii.

Gelée , 9 octets

Ḳm€4=”BḄỌ

Essayez-le en ligne!

Ḳ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 octets grâce à Erik l'Outgolfer

PHP, 67 octets

Limité à 8 lettres

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

Essayez-le en ligne!

PHP, 77 octets

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

Essayez-le en ligne!

Brain-Flak , 107 octets

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

Essayez-le en ligne!

+3 octets pour le -c indicateur.

Explication

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

Solution:

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

Exemple:

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

Explication:

Divisez la chaîne d'entrée sur " "pour donner des listes distinctes de FizzBuzz..., indexez dans chacune de ces listes au premier caractère (c'est-à-dire 0 4 8 ... 28). Renvoie une liste booléenne déterminée par si chaque caractère est "B"(ASCII 66). Convertissez ces listes en base 10, puis convertissez le résultat en chaîne.

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

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

Essayez-le en ligne!

Comment ça marche

            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 octets

trop d'octets, mais au moins lisible

Défini comme fonction, il est de 98 octets

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

tester:

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

Explication:

/(F)|(B)|./

Correspond aux lettres F et B et à tout le reste en tant que groupes

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

est une fonction qui capture les groupes, renvoie un 0 pour F et 1 pour B, ou ''

c est le caractère correspondant à
F et B sont maintenant des paramètres!
le 3 . le groupe est omis comme paramètre

F et B sont undefinedlorsque le 3e groupe est apparié
B est undefinedlorsque le groupe F est apparié

La chaîne 0100 .. etc résultante

est coupé en tranches de 8 octets

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

et traité comme une chaîne binaire 0b

shortC , 35 octets

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

Conversions dans ce programme:

• A - int main(int argc, char **argv){
• W - while(
• @ - argv
• P - putchar(
• Inséré automatiquement );}

Fortement basé sur la réponse de Doorknob.

APL (Dyalog Classic) , 17 octets

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

Explication

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

Essayez-le en ligne!

05AB1E , 15 octets

#vy„FBÃS'BQ2βçJ

Essayez-le en ligne!

Google Sheets, 94 octets

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

Je ne suis pas familier avec le binaire FizzBuzz mais il semble qu'ils soient délimités par des espaces, donc cette formule s'appuie sur cela. La logique est assez simple:

• Remplacer Fizzpar 0et Buzzpar1
• Fractionner le résultat en un tableau en utilisant un espace comme délimiteur
• Convertir chaque élément de binaire en décimal
• Remplacez chaque élément par son équivalent ASCII
• Rejoignez chaque élément sans délimiteur

Java 8, 117 115 octets

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

Je doute que vous puissiez faire beaucoup de remplacements de regex fantaisie en Java comme la plupart des autres réponses, principalement parce que vous ne pouvez rien faire avec les groupes de capture capturés dans Java-regexes .. (C'est-à-dire "$1".charAt(...)ou "$1".replace(...)n'est pas possible par exemple.)

Explication:

Essayez-le ici.

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 octets

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

Essayez-le en ligne!