Writing FizzBuzz with flip-flops

fizzbuzz.rb

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

I don't have a proof, but it seems to me that it's impossible to make it return false for every 6th iteration. I've solved it for 1, 2, 3, 4, 5, 7, 8, 9, 10, but not 6 :-(

@judofyr: Try building a truth table for them. That might help.

The problem is that it branches. In the 2-flip-flop if the state is false and we want the next values to be [true, false], then there are two possible inputs. There's also several ways to achieve the same input. One solution to the "dividable by 3" is the input: {start:true, stop:false}, {stop:true}, {start:false}. This can be solved either by having the same 2-cycle (true, false, true, false) in both start and stop ((s = !s) .. (s = !s)), but you can also use two different variables having a separate 2-cycle ((a = !a) .. (b = !b)).

Yay, after some improvements in my verifier-program, I now know there are solutions for everything from 1 to 17 \o/

Using flip-flops has to be benchmarked. I think that there is nothing wrong with using faster, more common methods. It doesn't make sense to iterate every value of the 1 to 100 range and then still have to eval each condition of a flip-flop.
Have you done a ven test ever? Just a thought. Map the state at every eval.

I'm confused about the !
Is this a not or a bang?

And here's a version of FizzBuzzBazz:

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