Different solutions for Fizz Buzz in Ruby

fizzbuzz.rb

def fizz_buzz_1(max)
  arr = []
  (1..max).each do |n|
    if ((n % 3 == 0) && (n % 5 == 0))
      arr << "FizzBuzz"
    elsif (n % 3 == 0)
      arr << "Fizz"
    elsif (n % 5 == 0)
      arr << "Buzz"
    else
      arr << n
    end
  end
  return arr
end

def fizz_buzz_2(max)
  arr = []
  (1..max).each do |n|
    if (n % 3 == 0)
      if (n % 5 == 0)
        arr << "FizzBuzz"
      else
        arr << "Fizz"
      end
    elsif (n % 5 == 0)
      arr << "Buzz"
    else
      arr << n
    end
  end
  return arr
end

def fizz_buzz_3(max)
  arr = []
  (1..max).each do |n|
    text = ""
    if (n % 3 == 0)
      text << "Fizz"
    end
    if (n % 5 == 0)
      text << "Buzz"
    end
    if !((n % 3 == 0) || (n % 5 == 0))
      text = n
    end
    arr << text
  end
  return arr
end

def fizzbuzz(int)
if int % 3 == 0 && int % 5 == 0
"FizzBuzz"
elsif int % 3 == 0
"Fizz"
elsif int % 5 == 0
"Buzz"
else int % 4 == 0
nil
end
end

70 characters

(1..100).map{|x|puts x%15==0?'FizzBuzz':x%5==0?'Buzz':x%3==0?'Fizz':x}

When I thought we already had way too many solutions... !

module BeingMultiple
  refine Integer do
    def eitherFizzOrBuzz!
      return "FizzBuzz" if multiple?(3) && multiple?(5)
      return "Fizz" if multiple?(3)
      return "Buzz" if multiple?(5)
      self
    end
    
    private
    
    def multiple?(target)
      self % target == 0
    end
  end
end

using BeingMultiple

puts (1..n).map(&:eitherFizzOrBuzz!).join("\n")

require "fizzbuzz"

RSpec.describe FizzBuzz do
  describe "#compute" do
    context "when number is dvisisble by 3" do
      it "returns fizz" do
        expect(FizzBuzz.compute(6)).to eq("fizz")
      end
    end

    context "when number is dvisisble by 5" do
      it "returns buzz" do
        expect(FizzBuzz.compute(10)).to eq("buzz")
      end
    end

    context "when number is dvisisble by both 3 and 5" do
      it "returns buzz" do
        expect(FizzBuzz.compute(15)).to eq("fizzbuzz")
      end
    end
  end
end


class FizzBuzz
  def self.compute(number)
    return "fizzbuzz" if (number % 15).zero?

    if (number % 3).zero? "fizz" else "buzz" end
  end
end

for n in 1..101
  print "Fizz" if n%3 == 0
  print "Buzz" if n%5 == 0
  print n unless n%3 == 0 || n%5 == 0
  print "\n"
end

(1..100).each_with_object([]) do |number, array|
  next array << "FizzBuzz" if number % 15 == 0
  next array << "Fizz" if number % 3 == 0
  next array << "Buzz" if number % 5 == 0

  array << number
end

Fizz Buzz, Object-Oriented Edition

module NumericRefinements
  refine Numeric do
    def divisible_by?(other) = remainder(other).zero?
  end
end

class Replacement
  def self.for(n) = @registered.find { it.valid? n }.new(n).to_s
  def initialize(n) = @n = n

  def self.valid?(n) = false
  def to_s = self.class.name
 
  private
  # Subclasses defined later take precedence
  def self.register(subclass) = (@registered ||= []).prepend subclass
  def self.inherited(subclass) = register subclass
end

using NumericRefinements
 
class TheNumber < Replacement
  def self.valid?(n) = true
  def to_s = @n.to_s
end
 
class Fizz < Replacement
  def self.valid?(n) = n.divisible_by?(3)
end
 
class Buzz < Replacement
  def self.valid?(n) = n.divisible_by?(5)
end
 
class FizzBuzz < Replacement
  def self.valid?(n) = Fizz.valid?(n) && Buzz.valid?(n)
end

class Game
  def initialize(limit: 16) = @limit = limit
  def to_a = (1..@limit).collect { Replacement.for it }
end
 
puts Game.new.to_a