FizzBuzz in Ruby and JavaScript with no conditionals and no modulo operator

01. fizz_buzz.rb

class Replacement
  class << self
    def for(n) = @@registered.find { it.valid? n }.new(n)
    def register(klass) = (@@registered ||= []).prepend klass
    def inherited(klass) = register(klass)
  end

  def initialize(n) = @n = n
end

class TheNumber < Replacement
  def self.valid?(n) = true
  def to_s = @n.to_s
end

class Fizz < Replacement
  def self.valid?(n) = n / 3.0 == n / 3
  def to_s = "Fizz"
end

class Buzz < Replacement
  def self.valid?(n) = n / 5.0 == n / 5
  def to_s = "Buzz"
end

class FizzBuzz < Replacement
  def self.valid?(n) = Fizz.valid?(n) && Buzz.valid?(n)
  def to_s = "FizzBuzz"
end

1.upto(20) { puts Replacement.for(it) }

02. fizz-buzz.js

class Replacement {
  static for = n => new (this.#registered.find(k => k.isValid(n)))(n)
  static register = klass => this.#registered.unshift(klass)
  static #registered = []

  constructor(n) { this.n = n }
}

class TheNumber extends Replacement {
  static isValid = () => true
  toString = () => this.n.toString()
}
Replacement.register(TheNumber)

class Fizz extends Replacement {
  static isValid = n => Math.floor(n / 3) === n / 3
  toString = () => "Fizz"
}
Replacement.register(Fizz)

class Buzz extends Replacement {
  static isValid = n => Math.floor(n / 5 ) === n / 5
  toString = () => "Buzz"
}
Replacement.register(Buzz)

class FizzBuzz extends Replacement {
  static isValid = n => Fizz.isValid(n) && Buzz.isValid(n)
  toString = () => "FizzBuzz"
}
Replacement.register(FizzBuzz)

for (let i = 0; i <= 20; i += 1) {
  console.log(`${Replacement.for(i)}`)
}