FizzBuzz solved using only bit twiddling (gist.github.com)

http://stackoverflow.com/questions/5284898/implement-divisio...

https://gist.github.com/ginkgo/7201708

The f[0-4] and t[0-2] functions emulate the state of a deterministic finite automata which determine divisibility of binary strings. The bits represent the binary strings. The left shift operator is used to "eat" bits.

See these two DFAs for an explanation:

http://stackoverflow.com/questions/15330027/regular-expressi...

http://ugccomputerscience.blogspot.com/2012/02/dfa-of-binary...

EDIT:

For those showing ways to do it with just addition and the like, I originally titled this "FizzBuzz using only bit twiddling" but a mod appears to have changed it...

[1] - https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpris...

  import sys
  n = 1000
  modthree = 0
  modfive = 0
  
  for i in range(n):
      if modthree == 3:
         modthree = 0; sys.stdout.write("fizz")
      if modfive == 5:
         modfive = 0; sys.stdout.write("buzz")
      if modthree and modfive:
         sys.stdout.write(i)
      sys.stdout.write("\n")
      modthree += 1; modfive += 1

To check if a number is divisible by 5, just check if the last digit is 0 or 5.

    fizz = cycle ["","","Fizz"]
    buzz = cycle ["","","","","Buzz"]
    fizzbuzz = zipWith (++) fizz buzz
    fb = zipWith (\n cs -> if cs == "" then show n else cs) [1..] fizzbuzz
    mapM_ putStrLn fb

  fizz = [nil,nil,'Fizz'].cycle
  buzz = [nil,nil,nil,nil,'Buzz'].cycle
  (1..100).zip(fizz,buzz) {|a| n,*fb=a.compact; puts fb.empty? ? n : fb.join }

    use List::Enumerator qw/E/;

    my $fizzbuzz =
        E(1)->countup
            ->zip(
                E("", "", "Fizz")->cycle,
                E("", "", "", "", "Buzz")->cycle
            )
            ->map( sub {
                my ($n, $fizz, $buzz) = @$_;
                $fizz . $buzz || $n;
            });

    $fizzbuzz->take(20)->each(sub {
        say $_;
    });

https://gist.github.com/tomtheisen/7203110

    a=b=c=(1..100).each do |num|
      print num, ?\r,
        ("Fizz" unless (a = !a) .. (a = !a)),
        ("Buzz" unless (b = !b) ... !((c = !c) .. (c = !c))),
      ?\n
    end

    .say for (('' xx 2, 'Fizz') xx * Z~ ('' xx 4, 'Buzz') xx *) Z|| 1 .. 100;

Functional programming for the win.

Also there's a pretty obvious conversion to recursion.

Either implementation can be even funnier if you memoize results in an array cache (so if you've already figured out the hard way that 999999mod3=0 then next time around when you check 1000000 you need not cycle all the way down to 0 for 1000000 because once you hit 999999 you already know from last time around how 999999 turned out. Bonus points for making your "cache" smaller, like implementing a LRU (or simpler) algorithm for the last several lookups rather than memoizing all one million results.

There's also a devilish way of (ab)using IEEE float arithmetic rounding errors which I forget at this moment.

If your language or a library attached to it handles arbitrary bases, there's a certain pattern to the last digit WRT multiples of 5 when expressing the number in base 5... so just to be a jerk you do the math for 3-mults in base 3, 5-mults in base 5, and your 0 to 100decimal counter in base 7 for the pure hell of it. OR amuse the interviewer because the base wasn't spec'd by running up to 100base7 (which is probably going to be a new ethernet standard soon enough).

Another fun form of rebellion is to implement an emulator for any machine language machine you can remember running simple BCD math. So here's a lame little Z80 emulator and a Z80 assembly routine to solve this using simple BCD math.

Deviant forms of trig obfuscation can be funny, essentially you rely on the trig libraries overflow behavior to dance 1/5 of the way around a unit circle each time, and when you're all done, if your angle is close enough to zero, I guess its divisible by 5. This is much funnier if you implement essentially a pentagon and then rotate it using quaternions

I think programmer brain puzzles are kind of dumb, when I was younger I would have just walked out of the room, but as I age the likelihood of a total smartass answer like above increases over time.

  #!/usr/bin/env rc


  for (i in `{seq 100}) {
  	toPrint = $i
  	toPost = ''

  	if (~ $i *5 || ~ $i *0 ) {
  		toPrint = Buzz
  		toPost = Buzz }

  	if (~ $i ([369] [147][258] [258][147] [369][0369]))
  		toPrint = Fizz ^ $toPost

  	echo $toPrint
  }

  fizzBuzz x = if null str then show x else str
    where str  = concat [tag | (n,tag) <- tags, x `rem` n == 0]
          tags = [(3,"Fizz"), (5,"Buzz")]

  main = mapM_ (putStrLn . fizzBuzz) [1..100]