multiply_prime_numbers_table 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1506319dd7940920c7efaaa4fd8b4d9b21ea91ce
+  data.tar.gz: 4ec6e307f93bad104f49d652145aecddcca584de
+SHA512:
+  metadata.gz: 7ef6f638fb3d15369d8a3ec48ecaa8f7d2d01669ee4a4966ca773e08d431619f855fd12d8748b5df593eed44ac01c8a3cf568a129af859b7d921e0e9ed00f981
+  data.tar.gz: f70322c94cbf0d7190bd334ee6cfa0ea2231f7a1233e6cb8aad4ccdc17db6338077d3d6bb18971cea89c3ef176e5db930865bb45ac4b9321fe5269f4694f176b

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem 'rake'
+gem 'rspec'

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (12.3.1)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  rspec
+
+BUNDLED WITH
+   1.16.1

data/README.md

@@ -0,0 +1,64 @@
+# Multiply prime numbers table
+
+This program prints out a multiplication table of the first N prime numbers.
+
+## Install
+
+From terminal inside root project run:
+
+````
+gem build multiply_prime_numbers_table.gemspec
+gem install ./multiply_prime_numbers_table-1.0.0.gem
+````
+
+Or install directly from ruby gems:
+
+````
+gem install multiply_prime_numbers_table
+````
+
+Install the dependencies with:
+
+````
+bundle install
+````
+
+## Run
+
+To run the program:
+
+````
+ruby -Ilib ./bin/multiply_prime_numbers_table
+````
+
+## Description
+
+* The program runs from the command line and print a table to STDOUT.
+* The first row and column of the table have the N primes, with each cell containing the product of the primes for the corresponding row and column.
+* Allows the user to specify different table sizes through a command line option. If the option is not used, the table will contain the first 10 primes by default.
+
+## Test
+
+You can run tests with:
+
+````
+rake
+````
+
+Or
+
+````
+rspec
+````
+
+## Comments
+
+The complexity of the program is exponential, the bigger N, the more complex the operations will be. To illustrate this matter i add a benchmark report to measure the performance in get_primes method, since it is the method with the highest cyclomatic complexity.
+
+To improve performance, the #get_primes method avoid to check the number if it's negative is 1 or is EVEN distinct of 2. With this considerations allow us to speed up the code and achieve high performance.
+
+Even for this little example having everything in one file doesn’t scale well. Thats why we separate the logic related to prime number and prime array in distinct files.
+
+Also decided to make small methods like #get_cell_size. Each method should make only one task, to simplify the code and allow it to scale. This method returns a number formatted in string, it's very simple but i decided to make it a method because this way is easier to modify. Maybe tomorrow we improve the way we print the table, and need to calculate cell size differently.
+
+Talking about the way it prints the table, i think it can be improve. Maybe give the user some range in between where you ensure that the table will look good or a use gem, but i wanted to use my own code and for this example i think fulfills its mission.

data/Rakefile

@@ -0,0 +1,10 @@
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+  
+rescue LoadError
+  abort '### Please run bundle install ###'
+end

data/bin/multiply_prime_numbers_table

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'multiply_prime_numbers_table'
+
+MultiplyPrimeNumbersTable.start

data/lib/multiply_prime_numbers_table.rb

@@ -0,0 +1,92 @@
+class MultiplyPrimeNumbersTable
+  require_relative "multiply_prime_numbers_table/prime_array"
+
+  class << self
+    def start
+      entry = ""
+
+      # The program will keep running until users enters an  X to Exit the program.
+      until entry == "X"
+        puts "\nMultiply prime numbers table"
+        print "=============================\n\n"
+        puts "Enter an integer N greater than zero to specify the table size."
+        puts "Any other entry will display a table containing the first 10 primes by default."
+        puts "If N is greater than 100000 first will calcualte the first N primes and then will confirm is user want to print the table."
+        puts "keep in mind that display a good table figure it depends on your screen size.\n\n"
+        integer = gets.strip.to_i
+        # If user enters something different of an integer greater than zero , the size table will be 10x10 by default.
+        size = integer != 0 ? integer  : 10
+        if size > 100000
+          puts "This may take a while ..."
+          prime_num = PrimeArray.get_primes(size)
+          puts "Warning! Print this size of table may cause trouble, but if you want to print it press Y"
+          entry = gets.strip.upcase
+          entry == "Y" ? create_table(prime_num) : false
+        else
+          # Get array of primes with the size defined
+          prime_num = PrimeArray.get_primes(size)
+          # Print the table
+          create_table(prime_num)
+        end
+
+        puts "Press X to Exit or any other key to calculate another table"
+        entry = gets.strip.upcase
+      end
+
+      puts "Exit"
+    end
+
+    def create_table(prime_num)
+      # Define prime numbers for first row and column
+      first_row = first_column = prime_num
+
+      # Get longest num in array
+      longest_num = longest_num_in_array(first_row)
+
+      # Define size for cells in table
+      cell_size = get_cell_size(longest_num)
+
+      # Leave blank first cell position to match first row with second coulum
+      (longest_num+1).times do
+        print " "
+      end
+
+      # Print first row of table
+      first_row.each { |row_num|
+        # Each cell will leave blank a space before and after the number inside, as left and rigth padding
+        print (" "+cell_size+" ") % row_num
+      }
+
+      # Print 2 empty rows
+      print "\n\n"
+
+      first_column.each { |column_num|
+        # Print first colum of table
+        # After first number of each row leave blank a space
+        print (cell_size+" ") % column_num
+
+        # Print inside cells
+        first_row.each {|row_num|
+          # Calculate the product of the primes for the corresponding row and column that intersecting in this cell.
+          # Print the product number leaving blank a space before and after
+          print (" "+cell_size+" ") % (row_num * column_num)
+        }
+
+        # Print 2 empty rows
+        print "\n\n"
+      }
+    end
+
+    def longest_num_in_array(array)
+      # Get length of the larger number in last cell of table
+      length_larger_num = (array.last**2).to_s.size
+    end
+
+    def get_cell_size(num)
+      # With %-4d format you make sure to print every cell with same size even if a number have less digits
+      "%-" + (num).to_s + "d"
+    end
+
+  end
+
+end

data/lib/multiply_prime_numbers_table/prime.rb

@@ -0,0 +1,15 @@
+class Integer
+
+  def is_prime?
+    # Avoid to check number if is negative, is 1 or is EVEN distinct of 2
+    return false if self <= 1 || (self.even? && self > 2)
+
+    # returns false if the module dividing num by other number from 2 to the square root of itsel is zero
+    2.upto(Math.sqrt(self).to_i) do |integer|
+      return false if (self % integer).zero?
+    end
+    # if none of the previous checks match it means it's a prime number
+    true
+  end
+
+end

data/lib/multiply_prime_numbers_table/prime_array.rb

@@ -0,0 +1,30 @@
+class PrimeArray
+  require_relative "prime"
+  require 'benchmark'
+
+  def self.get_primes(num)
+    time = Benchmark.measure {
+      @primes_array = []
+      counter = 2
+
+      until @primes_array.size == num
+        @primes_array << counter if counter.is_prime?
+        # Avoid to check even numbers because only even prime number is 2
+        (counter+1).even? ? counter += 1 : counter +=1
+      end
+    }
+
+    # I add this report just to show illustrate how it gets exponentialy complex as it increases num
+    puts "Time to takes to calculate first "+num.to_s+" prime numbers: "
+    n = time.real
+    Benchmark.bm(7) do |x|
+      x.report("for:")   { for i in 1..n; a = "1"; end }
+      x.report("times:") { (n.to_i).times do   ; a = "1"; end }
+      x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
+    end
+    puts "\n"
+
+    @primes_array
+  end
+
+end

data/spec/multiply_prime_numbers_table_spec.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rspec'
+require './lib/multiply_prime_numbers_table'
+
+describe  MultiplyPrimeNumbersTable do
+
+  before do
+    @table = MultiplyPrimeNumbersTable
+  end
+
+  describe "validations" do
+
+    context '#longest_num_in_array' do
+      it "Get length of the square of last number in array" do
+        array = [1,5,7,13]
+        expect(@table.longest_num_in_array(array)).to eql(3)
+      end
+    end
+
+    context '#get_cell_size' do
+      it "returns %Nd format" do
+        expect(@table.get_cell_size(5)).to eql("%-5d")
+      end
+    end
+
+  end
+end

data/spec/prime_array_spec.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'rspec'
+require './lib/multiply_prime_numbers_table/prime_array'
+require './lib/multiply_prime_numbers_table/prime'
+
+describe  PrimeArray do
+
+  describe "validations" do
+
+    context '#get_primes' do
+      it "returns an array" do
+        expect(PrimeArray.get_primes(10).class).to eql(Array)
+      end
+
+      it "returns an array with the size of the number that is passed as a parameter" do
+        expect(PrimeArray.get_primes(10).size).to eql(10)
+      end
+
+      it "returns an array of primes with the size of the number that is passed as a parameter" do
+        array = PrimeArray.get_primes(10).map{|num| num.is_prime?}
+        expect(array.include?(false)).to eql(false)
+      end
+    end
+
+  end
+end

data/spec/prime_spec.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'rspec'
+require './lib/multiply_prime_numbers_table/prime'
+
+describe  Integer do
+
+  describe "validations" do
+
+    context '#is_prime?' do
+      it "Evaluating negative nummber -1" do
+        expect(-1.is_prime?).to eql(false)
+      end
+
+      it "Evaluating number 1" do
+        expect(1.is_prime?).to eql(false)
+      end
+
+      it "Evaluating number 2" do
+        expect(2.is_prime?).to eql(true)
+      end
+
+      it "Evaluating number 10" do
+        expect(10.is_prime?).to eql(false)
+      end
+
+    end
+  end
+
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: multiply_prime_numbers_table
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Manuel Figueroa Andrade
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-16 00:00:00.000000000 Z
+dependencies: []
+description: The program run from the command line and print a table to STDOUT. The
+  first row and column of the table have the N primes, with each cell containing the
+  product of the primes for the corresponding row and column. Allow the user to specify
+  different table sizes through a command line option. If the option is not used,
+  the table will contain the first 10 primes by default.
+email: m.figand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/multiply_prime_numbers_table
+- lib/multiply_prime_numbers_table.rb
+- lib/multiply_prime_numbers_table/prime.rb
+- lib/multiply_prime_numbers_table/prime_array.rb
+- spec/multiply_prime_numbers_table_spec.rb
+- spec/prime_array_spec.rb
+- spec/prime_spec.rb
+homepage: http://rubygems.org/gems/multiply_prime_numbers_table
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Prints out a multiplication table of the first N prime numbers.
+test_files: []