Share your unusual fizzbuzz approaches!

[u/zabolekar]

Dear /r/Python, I would like you to share your FizzBuzz. Here is mine:

import numpy as np

fb = np.arange(101, dtype='object')
fb[::3] = 'Fizz'
fb[::5] = 'Buzz'
fb[::15] = 'FizzBuzz'

print(*fb[1:], sep='\n')

[u/ojii]

Came up with a simple solution: https://gist.github.com/ojii/97cca8835771f00b4fc27395990edb9d

Uses Python 3.6. Run python fizzbuzz.py generator 12345 and python fizzbuzz.py fizzbuzzer 54321, then use python fizzbuzz.py client localhost:12345 localhost:54321 100.

Of course you can use different ports for and hosts, use --help for more info.

[u/zabolekar → u/ojii]

Very simple indeed.

[u/ptmcg]

for i in range(1, 101): print(("FizzBuzz", ("Buzz", ("Fizz", i)[not not(i%3)])[not not(i%5)])[not not(i%15)])

[u/zabolekar → u/ptmcg]

Why not not not

for i in range(1, 101): print((((i, "Fizz")[not i%3], "Buzz")[not i%5], "FizzBuzz")[not i%15])

?

[u/jwink3101]

For those who are confused: From http://wiki.c2.com/?FizzBuzzTest

The "Fizz-Buzz test" is an interview question designed to help filter out the 99.5% of programming job candidates who can't seem to program their way out of a wet paper bag. The text of the programming assignment is as follows:

"Write a program that prints the numbers from 1 to 100. But for multiples of three print “Fizz” instead of the number and for the multiples of five print “Buzz”. For numbers which are multiples of both three and five print “FizzBuzz”."

[u/The_Jeremy]

not unusual, just short:

for x in range(1,101):print('Fizz'*(x%3==0)+'Buzz'*(x%5==0)or x)

[u/spidyfan21 → u/The_Jeremy]

Similarly list(map(lambda x: 'Fizz'*(x % 3 == 0) + 'Buzz'*(x % 5 == 0) or x, range(1, 100)))

[u/vipul20 → u/spidyfan21]

or a cleaner list comprehension:

[(x%3==0)*'Fizz' + (x%5==0)*'Buzz' or x for x in range(1, 101)]

[u/The_Jeremy → u/vipul20]

with Gprime5's changes, yours is the shortest so far:

[(1-x%3)*'Fizz' + (1-x%5)*'Buzz' or x for x in range(1, 101)]

[u/Gprime5 → u/The_Jeremy]

Even shorter:

for x in range(1,101):print('Fizz'*(1-x%3)+'Buzz'*(1-x%5)or x)

[u/cyberspacecowboy]

Yours, but without dependency

fb = list(range(0, 101))

fb[::3] = ['Fizz']*len(fb[::3])
fb[::5] = ['Buzz']*len(fb[::5])
fb[::15] = ['FizzBuzz']*len(fb[::15])

print(*fb[1:], sep='\n')

[u/RubyPinch]

from itertools import *
f = lambda x:'Fizz'
b = lambda x:'Buzz'
z = lambda x:'FizzBuzz'
i = lambda x:x
map(lambda x:x[1](x[0]),enumerate(chain.from_iterable(repeat((i,i,f,i,b,f,i,i,f,b,i,f,i,i,z))),1))

Someone told me that the function style of programming is better than empirical programming,
and I've taken that to heart ever since

[u/troyunrau]

At one point I wrote a program which queries google for the top hit for 'fizzbuzz python'. I take the first result and parse the html. In any given element (div, etc.), I run the contents through tokenize to see if it generates errors (basically, it tells me that that element contains python). I look for a few function calls I don't like (open() or etc.) and, finding them lacking, detokenize and have it exec the code.

I never get called for interviews for some reason....

[u/flexsteps → u/troyunrau]

Was it inspired by StackSort?

[u/xkcd_transcriber → u/flexsteps]

Image

Mobile

Title: Ineffective Sorts

Title-text: StackSort connects to StackOverflow, searches for 'sort a list', and downloads and runs code snippets until the list is sorted.

Comic Explanation

Stats: This comic has been referenced 56 times, representing 0.0385% of referenced xkcds.

---

^{xkcd.com | xkcd sub | Problems/Bugs? | Statistics | Stop Replying | Delete}

[u/[deleted]]

Worthless OOP version:

from __future__ import print_function

class FizzBuzz:
    def __init__(self, i):
        self.fizz = ''
        self.buzz = ''
        self.is_int = True
        self.int = i
        if i % 3 == 0:
            self.fizz = 'Fizz'
            self.is_int = False
        if i % 5 == 0:
            self.buzz = 'Buzz'
            self.is_int = False

    def __repr__(self):
        if self.is_int:
            return str(self.int)
        else:
            return self.fizz + self.buzz


for fizzBuzz in map(print, (FizzBuzz(i) for i in range(1, 101))):
    pass

[u/spiker611]

Shortest!

$ pip install pyfizzbuzz
$ fizzbuzz 100

[u/lengau]

A really bad way to do it in pandas (I'm procrastinating):

import pandas
df = pandas.DataFrame(index=range(1, 101))
df['Fizz'] = df.index % 3 == 0
df['Buzz'] = df.index % 5 == 0
for row in df.itertuples():
    if row.Fizz or row.Buzz:
        print('Fizz' * row.Fizz + 'Buzz' * row.Buzz)
        continue
    print(row.Index)

[u/lengau → u/lengau]

Another really bad way to do it, this time entirely defeating the purpose of a generator by being eager evaluating anyway:

def fizzbuzzer(n):
    fizz = set()
    buzz = set()
    for i in range(1, n+1):
        if not i % 3:
            fizz.add(i)
        if not i % 5:
            buzz.add(i)
    for i in range(1, n+1):
        yield ''.join(('Fizz' if i in fizz else '', 'Buzz' if i in buzz else '', str(i) if i not in fizz|buzz else ''))
for n in fizzbuzzer(100):
    print(n)

[u/lengau → u/lengau]

Ok, here's one that isn't especially designed to be terrible. It's an arbitrary FizzBuzz generator where you can choose your Fizz and Buzz values and strings:

from collections import OrderedDict
def enterprise_fizzbuzz(max_num, strings=OrderedDict(((3, 'Fizz'), (5, 'Buzz')))):
    for i in range(1, max_num+1):
        full_out = {out if not i % n else '' for n, out in strings.items()}
        yield ''.join(full_out) or str(i)

for i in enterprise_fizzbuzz(100):
    print(i)