kainz · August 29, 2015 13:59
diff --git a/gistfile1.py b/gistfile1.py
 "\n".join([ ":".join([str(c[0]), "".join([ c[1][i] for i in filter(lambda t: c[0] % t == 0,c[1].keys() ) ]) ]) for c in  [ (x, {3: 'Fizz', 5: 'Buzz'}) for x in range(100) ] ])

 # to make it even worse
 [ ":".join((str(n), re.sub(r'^((?:Fizz|Buzz){0,2}).+$', r'\1', reduce(lambda i, a: re.sub(r'((?<!x)(x{{{0}}})+(?!x))$'.format(a[0]),r'{}\1'.format(a[1]), i), ( (3, 'Fizz'), (5, 'Buzz') ) , 'x' * n )), )) for n in xrange(100) ]

 # Still tricky, but not nearly so horrible
 [ (x, "".join([ v for k,v in {3: 'Fizz', 5: 'Buzz'}.iteritems() if x % k == 0 ])) for x in range(100)]
 Why are these so horrible?  Well, number two is a classic example I think of mistyping.  Namely, we are generating a flat string then using a parameterized regex as a DFA to mutate the string into an annotated state, then using a final regex to separate the structure once again (if you could call it thath).

 Number one is also horrible, though seemingly shorter, because it combines multiple hard-to-parse features of Python into a single line.  Namely, we abuse scoping and parenthitical rules generate a series of tabular inputs to a test.

 Number three is tricky but not nearly as horrible, because proper list comprehension guard syntax and array unpacking is used to generate the same output, so we actually use a minimum number of constructs in this case.
	"\n".join([ ":".join([str(c[0]), "".join([ c[1][i] for i in filter(lambda t: c[0] % t == 0,c[1].keys() ) ]) ]) for c in [ (x, {3: 'Fizz', 5: 'Buzz'}) for x in range(100) ] ])

	# to make it even worse
	[ ":".join((str(n), re.sub(r'^((?:Fizz\|Buzz){0,2}).+$', r'\1', reduce(lambda i, a: re.sub(r'((?<!x)(x{{{0}}})+(?!x))$'.format(a[0]),r'{}\1'.format(a[1]), i), ( (3, 'Fizz'), (5, 'Buzz') ) , 'x' * n )), )) for n in xrange(100) ]

	# Still tricky, but not nearly so horrible
	[ (x, "".join([ v for k,v in {3: 'Fizz', 5: 'Buzz'}.iteritems() if x % k == 0 ])) for x in range(100)]
	Why are these so horrible? Well, number two is a classic example I think of mistyping. Namely, we are generating a flat string then using a parameterized regex as a DFA to mutate the string into an annotated state, then using a final regex to separate the structure once again (if you could call it thath).

	Number one is also horrible, though seemingly shorter, because it combines multiple hard-to-parse features of Python into a single line. Namely, we abuse scoping and parenthitical rules generate a series of tabular inputs to a test.

	Number three is tricky but not nearly as horrible, because proper list comprehension guard syntax and array unpacking is used to generate the same output, so we actually use a minimum number of constructs in this case.