fizzbuzzer 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 257500b27fdf676a85d3671553510fcde0ec2fa3
-  data.tar.gz: 69812a749e44213e790167fb8b925391ea85317f
+  metadata.gz: 6d65bae35e41b257f6d25062f4962ea9d96cc71f
+  data.tar.gz: 91b7bc1964e958ca432e6e45db8710e41573c878
 SHA512:
-  metadata.gz: 3eeb4670da60daa491e639286d11804329eee875f11847ee11d94a95a897ea2dffc2c01e625517bbca732e0f0896375e667f0b08daf04a38619d1176feb1a86d
-  data.tar.gz: 6116a56553ef18c25dda8ef1cd0903bf8206fc340dac31f5fea980824ac1e4e02138a6f91221cd3dccf667cf7376d3e68d031678ee32088e450f65c74eedaeda
+  metadata.gz: a619ba0dab2f37830a7a6161d2571789f048baa4973e10581cf2e8ae9d71e7487336a61418a3d1715eaf77707a4f0da5086e6237b5ea85dc07a8eb5886dca4fe
+  data.tar.gz: 4690304d9705f82d25695c512ddd9112b420381b7b46c8e3b71434374314cd600dd9ed2a7b3afda30b9ce98600e97db218383acee3bd2b691ec1baae20d37eb5

data/README.md

@@ -1,7 +1,7 @@
 # FizzBuzzer
 
 fizzbuzzer - 1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, Fizz Buzz, ... -
-a collection of algorithms for playing the word game for children that teaches division
+a collection of algorithms for playing the word game for children that teaches division e.g. 7/3=?
 (one of the four basic arithmetic operations in mathematics)
 or helps you find the world's best coders in programming job interviews -
 are you (re)using the fizzbuzzer library? ;-) - don't reinvent the wheel or the feedbuzzer!
@@ -178,7 +178,7 @@ def fizzbuzz
 end
 ```
 
-## Object-Oriented with New Fizznum Class
+### Object-Oriented with New Fizznum Class
 
 ``` ruby
 class Fizznum
@@ -241,7 +241,7 @@ end
 ```
 
 
-## Enumarator
+### Enumarator
 
 ```ruby
 module FizzBuzz
@@ -283,7 +283,7 @@ end
 ```
 
 
-## Lazy Enumerator to Infinity
+### Lazy Enumerator to Infinity
 
 ```ruby
 require "bigdecimal"
@@ -307,7 +307,7 @@ end
 ```
 
 
-## Poor Man's (Do-It-Yourself) Pattern Matching
+### Poor Man's (Do-It-Yourself) Pattern Matching
 
 ``` ruby
 def fizzbuzz
@@ -323,7 +323,7 @@ end
 ```
 
 
-## Pattern Matching with Noaidi
+### Pattern Matching with Noaidi
 
 ``` ruby
 require "noaidi"
@@ -341,7 +341,7 @@ end
 ```
 
 
-## Pattern Matching with dry-matcher
+### Pattern Matching with dry-matcher
 
 ``` ruby
 require "dry-matcher"
@@ -373,32 +373,78 @@ end
 ```
 
 
-## Test Driven Development (TDD)
+### Test Driven Development (TDD)
 
 ``` ruby
 describe FizzBuzz do
-  before do
-    @result = fizzbuzz
-  end
 
-  it "returns 'Fizz' for multiples of 3" do
-    @result[3-1].must_equal "Fizz"
+  describe "number is divisible" do
+    it "divisible by" do
+       divisible_by?(15,3).must_equal true
+    end
+    it "divisible by 3" do
+       divisible_by_3?(15).must_equal true
+    end
+    it "divisible by 5" do
+       divisible_by_5?(15).must_equal true
+    end
   end
 
-  it "returns 'Buzz' for multiples of 5" do
-    @result[5-1].must_equal "Buzz"
-  end
+  describe "number is fizzbuzz" do
+    before do
+      @result = fizzbuzz
+    end
 
-  it "returns 'FizzBuzz' for multiples of 3 and 5" do
-    @result[15-1].must_equal "FizzBuzz"
-  end
+    it "returns 'Fizz' for multiples of 3" do
+      @result[3-1].must_equal "Fizz"
+    end
+
+    it "returns 'Buzz' for multiples of 5" do
+      @result[5-1].must_equal "Buzz"
+    end
+
+    it "returns 'FizzBuzz' for multiples of 3 and 5" do
+      @result[15-1].must_equal "FizzBuzz"
+    end
 
-  it "returns the passed number if not a multiple of 3 or 5" do
-    @result[1-1].must_equal 1
+    it "returns the passed number if not a multiple of 3 or 5" do
+      @result[1-1].must_equal 1
+    end
   end
 end
 ```
 
+And here's another fizzbuzz algorithm with a classic `for` loop
+and using `divisible_by?` and `case/when/else` clauses:
+
+``` ruby
+def divisible_by?(numerator, denominator)
+  numerator % denominator == 0
+end
+
+def divisible_by_3?( numerator )
+  divisible_by?( numerator, 3 )
+end
+
+def divisible_by_5?( numerator )
+  divisible_by?( numerator, 5 )
+end
+
+def fizzbuzz
+  result = []
+  for n in 1..100 do
+    result << case
+              when divisible_by_3?(n) && divisible_by_5?(n) then "FizzBuzz"
+              when divisible_by_3?(n)                       then "Fizz"
+              when divisible_by_5?(n)                       then "Buzz"
+              else n
+              end
+    end
+  result
+end
+```
+
+
 Or use asserts for testing:
 
 ``` ruby
@@ -427,7 +473,8 @@ class TestFizzBuzz < Minitest::Test
 end
 ```
 
-And here's another fizzbuzz algorithm using a classic `for` loop:
+And here's yet another fizzbuzz algorithm with a classic `for` loop
+and classic `if/elsif/else`-clauses:
 
 ``` ruby
 def fizzbuzz
@@ -443,6 +490,7 @@ def fizzbuzz
 end
 ```
 
+
 Or use an all-in-one assert as used
 for testing all the fizzbuzz algorithms :-) in this repo:
 
@@ -468,7 +516,7 @@ end
 ```
 
 
-## With Parameterization
+### With Parameterization
 
 ``` ruby
 def fizzbuzz_engine(range, factors)
@@ -510,6 +558,84 @@ end
 ```
 
 
+### Use Cycle from Enumerable
+
+``` ruby
+def fizzbuzz
+  fizzy = [nil, nil, :Fizz].cycle
+  buzzy = [nil, nil, nil, nil, :Buzz].cycle
+
+  (1..100).map do |n|
+     "#{fizzy.next}#{buzzy.next}"[/.+/] || n
+  end
+end
+```
+
+
+
+### Code Golfing - One-Liners - The Shorter The Better!
+
+Tip:  Use `<1` for a shorter form of `==0`.
+
+
+**66 Bytes**
+
+``` ruby
+def fizzbuzz
+  (1..100).map{|n|s="";n%3<1&&s+="Fizz";n%5<1&&s+="Buzz";s[/.+/]||n}
+end
+```
+
+**65 Bytes**
+
+``` ruby
+def fizzbuzz
+  (1..100).map{|n|n%3<1?(n%5<1?"FizzBuzz":"Fizz"):(n%5<1?"Buzz":n)}
+end
+```
+
+**64 Bytes**
+
+``` ruby
+def fizzbuzz
+  (1..100).map{|n|n%3*n%5<1?(n%3<1?"Fizz":"")+(n%5<1?"Buzz":""):n}
+end
+```
+
+**62 Bytes**
+
+``` ruby
+def fizzbuzz
+  (1..100).map{|n|n%15<1?"FizzBuzz":n%5<1?"Buzz":n%3<1?"Fizz":n}
+end
+```
+
+**58 Bytes**
+
+``` ruby
+def fizzbuzz
+  (1..100).map{|n|"#{[:Fizz][n%3]}#{[:Buzz][n%5]}"[/.+/]||n}
+end
+```
+
+And the winner is...
+
+**54 Bytes**
+
+``` ruby
+def fizzbuzz
+  (1..100).map{|n|n%3<1&&x="Fizz";n%5<1?"#{x}Buzz":x||n}
+end
+```
+
+or
+
+``` ruby
+def fizzbuzz
+  (1..100).map{|n|["%sBuzz"%x=["Fizz"][n%3]][n%5]||x||n}
+end
+```
+
 
 ## Install
 

data/lib/fizzbuzzer.rb

@@ -78,9 +78,7 @@ end
 end # module FizzBuzzer
 
 
-
-## monkey patch for V3  - needs top level namespace
-##   todo/fix: use refinements - why? why not?
+## monkey patch for Fixnum - note: use refinements (in the future) - why? why not?
 class Fixnum
   def to_fizzbuzz
     if self % 3 == 0 && self % 5 == 0
@@ -92,19 +90,18 @@ class Fixnum
     else
       self
     end
-  end
+  end  # method to_fizzbuzz
 end
 
 
 module FizzBuzzer
 module V3
   def fizzbuzz
-     (1..100).map { |n| n.to_fizzbuzz }
+    (1..100).map { |n| n.to_fizzbuzz }
   end
 end
 
 
-
 module V4
 class Fizznum
   def initialize(n)
@@ -296,8 +293,7 @@ end
 end
 
 
-
-module V11
+module V11a
   def fizzbuzz
     result = []
     for n in 1..100 do
@@ -312,6 +308,34 @@ module V11
 end
 
 
+module V11b
+  def divisible_by?(numerator, denominator)
+    numerator % denominator == 0
+  end
+
+  def divisible_by_3?( numerator )
+    divisible_by?( numerator, 3 )
+  end
+
+  def divisible_by_5?( numerator )
+    divisible_by?( numerator, 5 )
+  end
+
+  def fizzbuzz
+    result = []
+    for n in 1..100 do
+      result << case
+                when divisible_by_3?(n) && divisible_by_5?(n) then "FizzBuzz"
+                when divisible_by_3?(n)                       then "Fizz"
+                when divisible_by_5?(n)                       then "Buzz"
+                else n
+                end
+    end
+    result
+  end
+end
+
+
 module V12a
 def fizzbuzz_engine(range, factors)
   range.map do |n|
@@ -350,6 +374,84 @@ end
 end
 
 
+module V13
+  def fizzbuzz
+    fizzy = [nil, nil, :Fizz].cycle
+    buzzy = [nil, nil, nil, nil, :Buzz].cycle
+ 
+    (1..100).map do |n|
+      "#{fizzy.next}#{buzzy.next}"[/.+/] || n
+    end
+  end
+end
+      
+
+module Golf
+  ## Notes:
+  ##   use <1 shorter form of ==0
+  ##
+  ##  "Fizz"[/.+/]  #=> "Fizz"
+  ##  "Buzz"[/.+/]  #=> "Buzz"
+  ##  ""[/.+/]      #=> nil
+  ##
+  ##  ["Fizz"][0]  #=> "Fizz"
+  ##  ["Fizz"][1]  #=> nil
+  ##  ["Fizz"][2]  #=> nil
+  ##
+  ##  ["Buzz"][0]  #=> "Buzz"
+  ##  ["Buzz"][1]  #=> "nil
+  ##
+  ##  ["%sBuzz" % "Fizz"] #=> "FizzBuzz"
+  ##  ["%sBuzz" % nil]    #=> "Buzz"
+
+  module V1     ## 66 bytes
+    def fizzbuzz
+      (1..100).map{|n|s="";n%3<1&&s+="Fizz";n%5<1&&s+="Buzz";s[/.+/]||n}
+    end
+  end
+
+  module V2      ## 65 bytes
+    def fizzbuzz
+      (1..100).map{|n|n%3<1?(n%5<1?"FizzBuzz":"Fizz"):(n%5<1?"Buzz":n)}
+    end
+  end
+  
+  module V3      ## 64 bytes
+    def fizzbuzz
+      (1..100).map{|n|n%3*n%5<1?(n%3<1?"Fizz":"")+(n%5<1?"Buzz":""):n}
+    end
+  end
+
+  module V4      ## 62 bytes
+    #  n%15==0 ? "FizzBuzz" : n%5==0 ? "Buzz" : n%3==0 ? "Fizz" : n
+    def fizzbuzz
+      (1..100).map{|n|n%15<1?"FizzBuzz":n%5<1?"Buzz":n%3<1?"Fizz":n}
+    end
+  end
+
+  module V5      ## 58 bytes
+    def fizzbuzz
+      (1..100).map{|n|"#{[:Fizz][n%3]}#{[:Buzz][n%5]}"[/.+/]||n}
+    end
+  end
+
+  module V6      ## 54 bytes
+    #  n%3 < 1 && x="Fizz"
+    #  n%5 < 1 ? "#{x}Buzz" : x || n
+    def fizzbuzz
+      (1..100).map{|n|n%3<1&&x="Fizz";n%5<1?"#{x}Buzz":x||n}
+    end
+  end
+
+  module V7      ## 54 bytes
+    def fizzbuzz
+      (1..100).map{|n|["%sBuzz"%x=["Fizz"][n%3]][n%5]||x||n}
+    end
+  end
+end # module Golf
+
+
+
 module Main     ## todo/check: use a class Runner instead (w/ include V1 etc.) - why? why not?
   extend V1
 end

data/lib/fizzbuzzer/version.rb

@@ -5,7 +5,7 @@ module FizzBuzzer
 
   MAJOR = 1
   MINOR = 1
-  PATCH = 0
+  PATCH = 1
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/test/test_driven.rb

@@ -10,26 +10,40 @@ require 'helper'
 
 describe FizzBuzz do
 
-  include FizzBuzzer::V11   ##  add (include) fizzbuzz method using algorithm V11
-
-  before do
-    @result = fizzbuzz
+  include FizzBuzzer::V11b   ##  add (include) fizzbuzz method using algorithm V11
+
+  describe "number is divisible" do
+    it "divisible by" do
+       divisible_by?(15,3).must_equal true
+    end
+    it "divisible by 3" do
+       divisible_by_3?(15).must_equal true
+    end
+    it "divisible by 5" do
+       divisible_by_5?(15).must_equal true
+    end
   end
 
-  it "returns 'Fizz' for multiples of 3" do
-    @result[3-1].must_equal "Fizz"
-  end
+  describe "number is fizzbuzz" do
+    before do     ## optimize? use before(:all) - why? why not?
+      @result = fizzbuzz
+    end
 
-  it "returns 'Buzz' for multiples of 5" do
-    @result[5-1].must_equal "Buzz"
-  end
+    it "returns 'Fizz' for multiples of 3" do
+      @result[3-1].must_equal "Fizz"
+    end
 
-  it "returns 'FizzBuzz' for multiples of 3 and 5" do
-    @result[15-1].must_equal "FizzBuzz"
-  end
+    it "returns 'Buzz' for multiples of 5" do
+      @result[5-1].must_equal "Buzz"
+    end
+
+    it "returns 'FizzBuzz' for multiples of 3 and 5" do
+      @result[15-1].must_equal "FizzBuzz"
+    end
 
-  it "returns the passed number if not a multiple of 3 or 5" do
-    @result[1-1].must_equal 1
+    it "returns the passed number if not a multiple of 3 or 5" do
+      @result[1-1].must_equal 1
+    end
   end
 end
 
@@ -37,7 +51,7 @@ end
 
 class TestFizzBuzz < Minitest::Test
 
-  include FizzBuzzer::V11   ##  add (include) fizzbuzz method using algorithm V11
+  include FizzBuzzer::V11a   ##  add (include) fizzbuzz method using algorithm V11
 
   def setup
     @result = fizzbuzz

data/test/test_fizzbuzz.rb

@@ -31,17 +31,32 @@ end
 end # class TestV1
 
 
-## auto-generate test classes (see model/sample above)
-##   todo/fix: use a version without eval - possible? why? why not?
-
-%w[V2a V2b V2c V2d V3 V4 V5 V6a V6b V7 V8 V9 V10 V11 V12a V12b].each do |name|
-  eval %Q(
-    class Test#{name} < MiniTest::Test
-      include FizzBuzzer::#{name}
-
-      def test_fizzbuzz
-        puts "running fizzbuzz #{name}..."
-        assert_equal FIZZBUZZES_1_TO_100, fizzbuzz
-      end
-    end)
+
+module FizzBuzz
+
+  ## auto-generate test classes (see model/sample above)
+  def self.test_class_for( m )
+    Class.new( MiniTest::Test ) do
+       include m
+       define_method :test_fizzbuzz do
+          puts "testing #{m.name}..."
+          assert_equal FIZZBUZZES_1_TO_100, fizzbuzz
+       end
+    end
+  end
+
+  ALGOS = [ V1, V2a, V2b, V2c, V2d, V3, V4, V5,
+            V6a, V6b, V7, V8, V9, V10, V11a, V11b, V12a, V12b, V13,
+            Golf::V1, Golf::V2, Golf::V3, Golf::V4, Golf::V5, Golf::V6, Golf::V7 ]
+
+  def self.build_tests
+    puts " auto-adding (building) test classes..."
+    ALGOS.each do |algo|
+      puts "  adding #{algo.name}..."
+      test_class_for( algo )
+    end
+  end
 end
+
+
+FizzBuzz.build_tests

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fizzbuzzer
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-24 00:00:00.000000000 Z
+date: 2018-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: noaidi