tasks_gem 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8232225b327bf7f4141561dc3bbe9b52ad6439878b3115fcb56af8ff3521d9a
-  data.tar.gz: 5c395313a4c35ca05ed3d2c0a54fab9a2d974defd198b6f0a243ca7c3079a769
+  metadata.gz: 168e34586ab652866a9102ea619046db0e38d9f9b9a996607d73ae2502074f12
+  data.tar.gz: bdf7b08378712569fb97bf230bbbb044cadafdc731e5c72b851b58e35239b657
 SHA512:
-  metadata.gz: b5c989afc03b71b5a46c5a6f526021120aa6af478ce7f3fe9e9c7d23fd48c4bcb6e153f2ec7f49d9f8d583e3cc51c74d88745b9dd1ad20367fd3acba58cca374
-  data.tar.gz: c3ce8e69d2850390ed7ba865e1eaa3ebc670d4dc15d1b34aa8d1495db3d2a0e471ba23e28292982b8d1e3bcea17ac554ee75ab72145b5f7b8e2737e1dd2bfa65
+  metadata.gz: fa24c7c8e2906722c08adb91a035d1438ea954e5d839477352b250d0ec89fda81d1680412d8ee81890cda5ec74245aece610e09384a5c2d9d871944ee8879195
+  data.tar.gz: ec2dd14ca07afb7dc4f6fa639c036f64fd7cabf745df29a1be6d911cc7fd65ff5b2da5551f3b5c6390a25902093739be1228b6dae7a24d9b28d307404025ec68

data/{.gitignore → .gitignire}

@@ -9,4 +9,4 @@
 .idea/
 
 # rspec failure tracking
-.rspec_status
+.rspec_status

data/Gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in tasks_gem.gemspec
 gemspec

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    tasks_gem (0.1.4)
-      run_tests (~> 0.1.1)
+    tasks_gem (0.1.5)
+      run_tests (~> 0.1.2)
 
 GEM
   remote: https://rubygems.org/
@@ -22,7 +22,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-support (3.8.0)
-    run_tests (0.1.1)
+    run_tests (0.1.2)
 
 PLATFORMS
   ruby

data/README.md

@@ -1,6 +1,8 @@
-# Tasks
+# tasks_gem
 
 50 tasks
+https://rubygems.org/gems/tasks_gem
+
 Book with tasks http://libgen.io/book/index.php?md5=02CEF7BC8F9FAF75690C1CBE83BE3B70
 
 ## Installation
@@ -25,15 +27,19 @@ Example:
 ```ruby
 require 'tasks'
 
-puts Tasks::Task.new.task(num: 2)
-print Tasks::Task.new.number_array(digit: 2356), "\n"
-print Tasks::Task.new.task_1(number_a: 2, number_b: 5), "\n"
+print Tasks::Task.number_array(digit: 2356), "\n"
+print Tasks::Task.task_1(number_a: 2, number_b: 5), "\n"
 ```
 
 All methods:
 ```ruby
-print Tasks::Task.instance_methods(false), "\n"
+print Tasks::Task.methods(false), "\n"
 ```
+## Dependencies:
+
+run_tests ~> 0.1.1
+https://rubygems.org/gems/run_tests
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/tasks/version.rb

@@ -1,3 +1,3 @@
 module Tasks
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/tasks.rb

@@ -1,503 +1,522 @@
 require "tasks/version"
+require "matrix"
 
 module Tasks
   class Error < StandardError; end
 
   # 50 tasks
   class Task
-    def task(num:)
-      puts "\n Task #{num}"
-    end
+    class << self
+      def task(num:)
+        puts "\n Task #{num}"
+      end
 
-    # number => array, example 234 => [2, 3, 4]
-    def number_array(digit:)
-      digit.to_s.split('').map(&:to_i)
-    end
+      # number => array, example 234 => [2, 3, 4]
+      def number_array(digit:)
+        digit.to_s.split('').map(&:to_i)
+      end
 
-    # array of prime numbers
-    def array_separators(array:)
-      array.select { |x| (1..x).select { |y| (x % y).zero? }.length <= 2 }
-    end
+      # array of prime numbers
+      def array_separators(array:)
+        array.select { |x| (1..x).select { |y| (x % y).zero? }.length <= 2 }
+      end
 
-    # matrix n x m
-    def new_matrix(n_lines:, m_lines:)
-      array = []
-      (0..(n_lines - 1)).each do |i|
-        array[i] = []
-        (0..(m_lines - 1)).each { array[i].push(rand(1..10)) }
+      # matrix n x m
+      def new_matrix(n_lines:, m_lines:)
+        array = []
+        (0..(n_lines - 1)).each do |i|
+          array[i] = []
+          (0..(m_lines - 1)).each { array[i].push(rand(1..10)) }
+        end
+        print array, "\n"
+        array
       end
-      print array, "\n"
-      array
-    end
 
-    # if digit not in diapason lower_bound..top_bound enter new n
-    def check_digit(digit:, lower_bound: 1, top_bound: 10)
-      until (lower_bound..top_bound).cover? digit
-        puts 'incorrect value'
-        puts 'take again'
-        digit = gets.to_i
+      # if digit not in diapason lower_bound..top_bound enter new n
+      def check_digit(digit:, lower_bound: 1, top_bound: 10)
+        until (lower_bound..top_bound).cover? digit
+          puts 'incorrect value'
+          puts 'take again'
+          digit = gets.to_i
+        end
+        digit
       end
-      digit
-    end
 
-    # array with random digits in diapason lower_bound..y
-    def new_array(quantity:, lower_bound: -100, top_bound: 100)
-      array = []
-      quantity.times { array.push(rand(lower_bound..top_bound)) }
-      print "Elements: #{array} \n"
-      array
-    end
+      # array with random digits in diapason lower_bound..y
+      def new_array(quantity:, lower_bound: -100, top_bound: 100)
+        array = []
+        quantity.times { array.push(rand(lower_bound..top_bound)) }
+        print "Elements: #{array} \n"
+        array
+      end
 
-    # hint when comparing numbers
-    def hint(digit1:, digit2:)
-      if digit1 > digit2
-        'more than needed'
-      elsif digit1 < digit2
-        'less than needed'
+      # hint when comparing numbers
+      def hint(digit1:, digit2:)
+        if digit1 > digit2
+          'more than needed'
+        elsif digit1 < digit2
+          'less than needed'
+        end
       end
-    end
 
-    def task_1(number_a:, number_b:)
-      task(num: 1)
-      { sum: number_a + number_b,
-        difference: number_a - number_b,
-        multiplication: number_a * number_b }
-    end
+      def task_1(number_a:, number_b:)
+        task(num: 1)
+        sum = number_a + number_b
+        diff = number_a - number_b
+        mult = number_a * number_b
+        { sum: sum,
+          difference: diff,
+          multiplication: mult }
+      end
 
-    def task_2(number_a:, number_b:)
-      task(num: 2)
-      ((number_a.abs - number_b.abs) / (1 + (number_a * number_b).abs)).round(4)
-    end
+      def task_2(number_a:, number_b:)
+        task(num: 2)
+        difference = number_a.abs - number_b.abs
+        multiplication = (number_a * number_b).abs
+        (difference / (1 + multiplication)).round(4)
+      end
 
-    def task_3(edge_length:)
-      task(num: 3)
-      { Volume: edge_length**3, Square: edge_length**2 * 6 }
-    end
+      def task_3(edge_length:)
+        task(num: 3)
+        volume = edge_length**3
+        square = edge_length**2 * 6
+        { Volume: volume, Square: square }
+      end
 
-    def task_6(cathetus_a:, cathetus_b:)
-      task(num: 6)
-      { hypotenuse: Math.sqrt(cathetus_a**2 + cathetus_b**2).round(4),
-        Square: cathetus_a * cathetus_b / 2 }
-    end
+      def task_6(cathetus_a:, cathetus_b:)
+        task(num: 6)
+        hypotenuse = Math.sqrt(cathetus_a**2 + cathetus_b**2).round(4)
+        square = cathetus_a * cathetus_b / 2
+        { hypotenuse: hypotenuse,
+          Square: square }
+      end
 
-    def task_8(n_corners:, radius:)
-      task(num: 8)
-      result = 2 * radius * Math.tan(3.14 / n_corners) * n_corners
-      result.round(4)
-    end
+      def task_8(n_corners:, radius:)
+        task(num: 8)
+        result = 2 * radius * Math.tan(3.14 / n_corners) * n_corners
+        result.round(4)
+      end
 
-    def task_9(resistance1:, resistance2:, resistance3:)
-      task(num: 9)
-      (1 / (1 / resistance1 + 1 / resistance2 + 1 / resistance3)).round(4)
-    end
+      def task_9(resistance1:, resistance2:, resistance3:)
+        task(num: 9)
+        (1 / (1 / resistance1 + 1 / resistance2 + 1 / resistance3)).round(4)
+      end
 
-    def task_10(height:)
-      task(num: 10)
-      result = Math.sqrt((2 * height) / 9.81)
-      result.round(2)
-    end
+      def task_10(height:)
+        task(num: 10)
+        result = Math.sqrt((2 * height) / 9.81)
+        result.round(2)
+      end
 
-    def task_12(side_of_triangle:)
-      task(num: 12)
-      result = Math.sqrt(3) * side_of_triangle / 4 * side_of_triangle**2
-      result.round(2)
-    end
+      def task_12(side_of_triangle:)
+        task(num: 12)
+        result = Math.sqrt(3) * side_of_triangle / 4 * side_of_triangle**2
+        result.round(2)
+      end
 
-    def task_13(pendulum_length:)
-      task(num: 13)
-      (2 * 3.14 * Math.sqrt(pendulum_length / 9.81)).round(2)
-    end
+      def task_13(pendulum_length:)
+        task(num: 13)
+        (2 * 3.14 * Math.sqrt(pendulum_length / 9.81)).round(2)
+      end
 
-    def task_15(cathetus_a:, hypotenuse:)
-      task(num: 15)
-      cathetus_b = Math.sqrt(hypotenuse**2 - cathetus_a**2).round(2)
-      { cathetus_b: cathetus_b,
-        Square: ((cathetus_a + cathetus_b - hypotenuse) / 2).round(2) }
-    end
+      def task_15(cathetus_a:, hypotenuse:)
+        task(num: 15)
+        cathetus_b = Math.sqrt(hypotenuse**2 - cathetus_a**2).round(2)
+        square = ((cathetus_a + cathetus_b - hypotenuse) / 2).round(2)
+        { cathetus_b: cathetus_b,
+          Square: square }
+      end
 
-    def task_16(circumference:)
-      task(num: 16)
-      result = Math::PI * Math.sqrt(circumference / (2 * Math::PI))
-      result.round(2)
-    end
+      def task_16(circumference:)
+        task(num: 16)
+        result = Math::PI * Math.sqrt(circumference / (2 * Math::PI))
+        result.round(2)
+      end
 
-    def task_24(coordinate_x1:, coordinate_x2:, coordinate_y1:, coordinate_y2:)
-      task(num: 24)
-      difference_x = coordinate_x1 - coordinate_x2
-      difference_y = coordinate_y1 - coordinate_y2
-      result = Math.sqrt(difference_x**2 + difference_y**2)
-      result.round(2)
-    end
+      def task_24(coordinate_x1:, coordinate_x2:,
+                  coordinate_y1:, coordinate_y2:)
+        task(num: 24)
+        difference_x = coordinate_x1 - coordinate_x2
+        difference_y = coordinate_y1 - coordinate_y2
+        result = Math.sqrt(difference_x**2 + difference_y**2)
+        result.round(2)
+      end
 
-    def task_30(real_num:)
-      task(num: 30)
-      degree3 = real_num**3
-      middle = 2 * real_num + 3 * real_num**2
-      res1 = 1 - middle - 4 * degree3
-      res2 = 1 + middle + 4 * degree3
-      { result1: res1, result2: res2 }
-    end
+      def task_30(real_num:)
+        task(num: 30)
+        degree3 = real_num**3
+        middle = 2 * real_num + 3 * real_num**2
+        res1 = 1 - middle - 4 * degree3
+        res2 = 1 + middle + 4 * degree3
+        { result1: res1, result2: res2 }
+      end
 
-    def task_33(real_number_x:, real_number_y:)
-      task(num: 33)
-      array = [real_number_x, real_number_y]
-      { min: array.min, max: array.max }
-    end
+      def task_33(real_number_x:, real_number_y:)
+        task(num: 33)
+        array = [real_number_x, real_number_y]
+        { min: array.min, max: array.max }
+      end
 
-    def task_34(real_number_x:, real_number_y:, real_number_z:)
-      task(num: 34)
-      array = [real_number_x, real_number_y, real_number_z]
-      { min: array.min, max: array.max }
-    end
+      def task_34(real_number_x:, real_number_y:, real_number_z:)
+        task(num: 34)
+        array = [real_number_x, real_number_y, real_number_z]
+        { min: array.min, max: array.max }
+      end
 
-    def task_41(natural_number = 3)
-      task(num: 41)
-      new_array(quantity: natural_number).select { |x| x <= 3 && x >= 1 }
-    end
+      def task_41(natural_number = 3)
+        task(num: 41)
+        new_array(quantity: natural_number).select { |x| x <= 3 && x >= 1 }
+      end
 
-    def task_43(natural_number = 3)
-      task(num: 43)
-      array = new_array(quantity: natural_number)
-      array2 = array.select { |x| x > 0 }.map { |x| x**2 }
-      { array: array, array2: array2 }
-    end
+      def task_43(natural_number = 3)
+        task(num: 43)
+        array = new_array(quantity: natural_number)
+        array2 = array.select { |x| x > 0 }.map { |x| x**2 }
+        { array: array, array2: array2 }
+      end
 
-    def task_62(integer:)
-      task(num: 62)
-      (integer % 2).zero?
-    end
+      def task_62(integer:)
+        task(num: 62)
+        (integer % 2).zero?
+      end
 
-    def task_64(natural_number:)
-      task(num: 64)
-      natural_number / 100
-    end
+      def task_64(natural_number:)
+        task(num: 64)
+        natural_number / 100
+      end
 
-    def task_65(natural_number:)
-      task(num: 65)
-      sum_array = number_array(digit: natural_number).reduce(:+)
-      sum_array**3 == natural_number**2
-    end
+      def task_65(natural_number:)
+        task(num: 65)
+        sum_array = number_array(digit: natural_number).reduce(:+)
+        sum_array**3 == natural_number**2
+      end
 
-    def task_67(natural_number:)
-      task(num: 67)
-      array = number_array(digit: natural_number)
-      penultimate_number = array[array.length - 2] if natural_number >= 10
-      { digits_number: array.length,
-        sum: array.reduce(:+),
-        last_digit: array[array.length - 1],
-        first_digit: array[0],
-        penultimate_number: penultimate_number }
-    end
+      def task_67(natural_number:)
+        task(num: 67)
+        array = number_array(digit: natural_number)
+        penultimate_number = array[array.length - 2] if natural_number >= 10
+        { digits_number: array.length,
+          sum: array.reduce(:+),
+          last_digit: array[array.length - 1],
+          first_digit: array[0],
+          penultimate_number: penultimate_number }
+      end
 
-    def task_182(natural_number:)
-      task(num: 182)
-      array = new_array(quantity: natural_number)
-      array2 = array.select { |elem| (elem % 5).zero? && elem % 7 != 0 }
-      { arr_new: array2,
-        sum: array2.reduce(:+),
-        quantity: array2.length }
-    end
+      def task_182(natural_number:)
+        task(num: 182)
+        array = new_array(quantity: natural_number)
+        array2 = array.select { |elem| (elem % 5).zero? && elem % 7 != 0 }
+        sum = array2.reduce(:+)
+        { arr_new: array2,
+          sum: sum,
+          quantity: array2.length }
+      end
 
-    def task_185(natural_number:)
-      task(num: 185)
-      array = new_array(quantity: natural_number)
-      array2 = array.select { |elem| elem > 0 }
-      sum = if array2 != []
-              array2.reduce(:+)**2
-            else
-              0
-            end
-      { array: array2, sum: sum }
-    end
+      def task_185(natural_number:)
+        task(num: 185)
+        array = new_array(quantity: natural_number)
+        array2 = array.select { |elem| elem > 0 }
+        sum = if array2 != []
+                array2.reduce(:+)**2
+              else
+                0
+              end
+        { array: array2, sum: sum }
+      end
 
-    def task_191(natural_number:)
-      task(num: 191)
-      quantity = 0
-      array = new_array(quantity: natural_number)
-      array.map! do |elem|
-        quantity += 1 if elem > 7
-        elem > 7 ? 7 : elem
+      def task_191(natural_number:)
+        task(num: 191)
+        quantity = 0
+        array = new_array(quantity: natural_number)
+        array.map! do |elem|
+          quantity += 1 if elem > 7
+          elem > 7 ? 7 : elem
+        end
+        { array: array, quantity: quantity }
       end
-      { array: array, quantity: quantity }
-    end
 
-    def task_205(natural_number:)
-      task(num: 205)
-      array = new_array(quantity: natural_number)
-      { array: array,
-        max: array.map(&:abs).max,
-        sum: array.map { |x| x * x }.reduce(:+) }
-    end
+      def task_205(natural_number:)
+        task(num: 205)
+        array = new_array(quantity: natural_number)
+        { array: array,
+          max: array.map(&:abs).max,
+          sum: array.map { |x| x * x }.reduce(:+) }
+      end
 
-    def task_207(natural_number:)
-      task(num: 207)
-      arr = number_array(digit: natural_number).delete_if do |x|
-        x.zero? || x == 5
+      def task_207(natural_number:)
+        task(num: 207)
+        arr = number_array(digit: natural_number).delete_if do |x|
+          x.zero? || x == 5
+        end
+        arr.join.to_i
       end
-      arr.join.to_i
-    end
 
-    def task_224(natural_number:)
-      task(num: 224)
-      (1..natural_number).select { |x| (natural_number % x).zero? }
-    end
+      def task_224(natural_number:)
+        task(num: 224)
+        (1..natural_number).select { |x| (natural_number % x).zero? }
+      end
 
-    def task_225(natural_number:)
-      task(num: 225)
-      (1..natural_number).select do |x|
-        (natural_number % x**2).zero? && natural_number % x**3 != 0
+      def task_225(natural_number:)
+        task(num: 225)
+        (1..natural_number).select do |x|
+          (natural_number % x**2).zero? && natural_number % x**3 != 0
+        end
       end
-    end
 
-    def task_230(natural_number:)
-      task(num: 230)
-      min = 1000
-      num_array = new_array(quantity: natural_number)
-      num_array.inject do |x, y|
-        min = (x - y).abs if (x - y).abs < min
-        y
+      def task_230(natural_number:)
+        task(num: 230)
+        min = 1000
+        num_array = new_array(quantity: natural_number)
+        num_array.inject do |x, y|
+          min = (x - y).abs if (x - y).abs < min
+          y
+        end
+        min
       end
-      min
-    end
 
-    def task_272(natural_number = 50)
-      task(num: 272)
-      precipitation = new_array(quantity: natural_number,
-                                lower_bound: 1,
-                                top_bound: 100)
-      average = precipitation.reduce(:+) / precipitation.size
-      deviation = []
-      precipitation.each { |x| deviation.push(x - average) }
-      { array: precipitation,
-        average: average,
-        deviation: deviation }
-    end
+      def task_272(natural_number = 50)
+        task(num: 272)
+        precipitation = new_array(quantity: natural_number,
+                                  lower_bound: 1,
+                                  top_bound: 100)
+        average = precipitation.reduce(:+) / precipitation.size
+        deviation = []
+        precipitation.each { |x| deviation.push(x - average) }
+        { array: precipitation,
+          average: average,
+          deviation: deviation }
+      end
 
-    def task_279(natural_number:)
-      task(num: 279)
-      a = new_array(quantity: natural_number)
-      b = new_array(quantity: natural_number).reverse!
-      ab = []
-      (0..natural_number - 1).each { |i| ab.push(a[i] + b[i]) }
-      { array_a: a, array_b: b, array_ab: ab }
-    end
+      def task_279(natural_number:)
+        task(num: 279)
+        a = new_array(quantity: natural_number)
+        b = new_array(quantity: natural_number).reverse!
+        ab = []
+        (0..natural_number - 1).each { |i| ab.push(a[i] + b[i]) }
+        { array_a: a, array_b: b, array_ab: ab }
+      end
 
-    def task_302(natural_number:)
-      task(num: 302)
-      number = number_array(digit: natural_number)
-      number.uniq!
-      number.length
-    end
+      def task_302(natural_number:)
+        task(num: 302)
+        number = number_array(digit: natural_number)
+        number.uniq!
+        number.length
+      end
 
-    def task_317(natural_number = 10)
-      task(num: 317)
-      array = new_array(quantity: natural_number)
-      sum_array = 0
-      (0..natural_number - 1).each { |i| sum_array += array[i]**(i + 1) }
-    end
+      def task_317(natural_number = 10)
+        task(num: 317)
+        array = new_array(quantity: natural_number)
+        sum_array = 0
+        (0..natural_number - 1).each { |i| sum_array += array[i]**(i + 1) }
+      end
 
-    def task_325(natural_number:)
-      task(num: 325)
-      separators = (1..natural_number).select { |x| (natural_number % x).zero? }
-      array_separators(array: separators)
-    end
+      def task_325(natural_number:)
+        task(num: 325)
+        separators = (1..natural_number).select do |x|
+          (natural_number % x).zero?
+        end
+        array_separators(array: separators)
+      end
 
-    def task_328(lower_bound = 1, top_bound = 100)
-      task(num: 328)
-      array_separators(array: (lower_bound..top_bound))
-    end
+      def task_328(lower_bound = 1, top_bound = 100)
+        task(num: 328)
+        array_separators(array: (lower_bound..top_bound))
+      end
 
-    def task_536(natural_number:)
-      task(num: 536)
-      array = new_array(quantity: natural_number)
-      { array: array, identical_elements: array != array.uniq }
-    end
+      def task_536(natural_number:)
+        task(num: 536)
+        array = new_array(quantity: natural_number)
+        { array: array, identical_elements: array != array.uniq }
+      end
 
-    def task_555(natural_number:)
-      task(num: 555)
-      puts 'pascals triangle'
-      a = []
-      (0..natural_number - 1).each do |i|
-        a[i] = []
-        a[i].push(1)
-        if i > 0
-          (0..a[i - 1].size - 2).each do |j|
-            a[i].unshift(a[i - 1][j] + a[i - 1][j + 1])
+      def task_555(natural_number:)
+        task(num: 555)
+        puts 'pascals triangle'
+        a = []
+        (0..natural_number - 1).each do |i|
+          a[i] = []
+          a[i].push(1)
+          if i > 0
+            (0..a[i - 1].size - 2).each do |j|
+              a[i].unshift(a[i - 1][j] + a[i - 1][j + 1])
+            end
+            a[i].unshift(1)
           end
-          a[i].unshift(1)
+          print a[i], "\n"
         end
-        print a[i], "\n"
+        a
       end
-      a
-    end
 
-    def task_561(natural_number:)
-      task(num: 561)
-      new_array = []
-      (1..natural_number).each do |s|
-        array = number_array(digit: s * s)
-        if array.last(number_array(digit: s).size).join.to_i == s
-          new_array.push(s)
+      def task_561(natural_number:)
+        task(num: 561)
+        new_array = []
+        (1..natural_number).each do |s|
+          array = number_array(digit: s * s)
+          if array.last(number_array(digit: s).size).join.to_i == s
+            new_array.push(s)
+          end
         end
+        new_array
       end
-      new_array
-    end
 
-    def task_606(side_a:, side_b:, side_c:, side_d:)
-      task(num: 606)
-      rectangle = [side_a, side_b, side_c, side_d]
-      sum_rectangle = rectangle.reduce(:+)
-      rectangle_flag = true
-      (0..3).each do |i|
-        rectangle_flag = false if (sum_rectangle - rectangle[i]) < rectangle[i]
+      def task_606(side_a:, side_b:, side_c:, side_d:)
+        task(num: 606)
+        rectangle = [side_a, side_b, side_c, side_d]
+        sum = rectangle.reduce(:+)
+        rectangle_flag = true
+        (0..3).each do |i|
+          rectangle_flag = false if (sum - rectangle[i]) < rectangle[i]
+        end
+        rectangle_flag
       end
-      rectangle_flag
-    end
-
-    def task_697(natural_number1:, natural_number2:, natural_number3:)
-      task(num: 697)
-      matrix_a = Matrix.rows(new_matrix(n_lines: natural_number1,
-                                        m_lines: natural_number2))
-      matrix_b = Matrix.rows(new_matrix(n_lines: natural_number2,
-                                        m_lines: natural_number3))
-      { matrix_a: matrix_a,
-        matrix_b: matrix_b,
-        result: matrix_a * matrix_b }
-    end
 
-    def task_698(natural_number:)
-      task(num: 698)
-      matrix = Matrix.rows(new_matrix(n_lines: natural_number,
-                                      m_lines: natural_number))
-      { matrix: matrix, result: matrix**2 }
-    end
+      def task_697(natural_number1:, natural_number2:, natural_number3:)
+        task(num: 697)
+        matrix_a = Matrix.rows(new_matrix(n_lines: natural_number1,
+                                          m_lines: natural_number2))
+        matrix_b = Matrix.rows(new_matrix(n_lines: natural_number2,
+                                          m_lines: natural_number3))
+        mult = matrix_a * matrix_b
+        { matrix_a: matrix_a,
+          matrix_b: matrix_b,
+          result: mult }
+      end
 
-    def task_699(natural_number:)
-      task(num: 699)
-      matrix_a = Matrix.rows(new_matrix(n_lines: natural_number,
+      def task_698(natural_number:)
+        task(num: 698)
+        matrix = Matrix.rows(new_matrix(n_lines: natural_number,
                                         m_lines: natural_number))
-      matrix_b = Matrix.rows(new_matrix(n_lines: natural_number,
-                                        m_lines: natural_number))
-      result = matrix_a * matrix_b - matrix_b * matrix_a
-      { matrix_a: matrix_a,
-        matrix_b: matrix_b,
-        result: result }
-    end
+        { matrix: matrix, result: matrix**2 }
+      end
 
-    def task_704(natural_number:)
-      task(num: 704)
-      matrix_a = Matrix.rows(new_matrix(n_lines: natural_number,
-                                        m_lines: natural_number))
-      matrix_b = Matrix.rows(new_matrix(n_lines: natural_number,
-                                        m_lines: natural_number))
-      matrix_c = Matrix.rows(new_matrix(n_lines: natural_number,
-                                        m_lines: natural_number))
-      { matrix_a: matrix_a, matrix_b: matrix_b,
-        matrix_c: matrix_c, result: (matrix_a + matrix_b) * matrix_c }
-    end
+      def task_699(natural_number:)
+        task(num: 699)
+        matrix_a = Matrix.rows(new_matrix(n_lines: natural_number,
+                                          m_lines: natural_number))
+        matrix_b = Matrix.rows(new_matrix(n_lines: natural_number,
+                                          m_lines: natural_number))
+        result = matrix_a * matrix_b - matrix_b * matrix_a
+        { matrix_a: matrix_a, matrix_b: matrix_b, result: result }
+      end
 
-    def task_710(natural_number1:, natural_number2:)
-      task(num: 710)
-      m = Matrix.rows(new_matrix(n_lines: natural_number1,
-                                 m_lines: natural_number2))
-      m.transpose
-    end
+      def task_704(natural_number:)
+        task(num: 704)
+        matrix_a = Matrix.rows(new_matrix(n_lines: natural_number,
+                                          m_lines: natural_number))
+        matrix_b = Matrix.rows(new_matrix(n_lines: natural_number,
+                                          m_lines: natural_number))
+        matrix_c = Matrix.rows(new_matrix(n_lines: natural_number,
+                                          m_lines: natural_number))
+        result = (matrix_a + matrix_b) * matrix_c
+        { matrix_a: matrix_a, matrix_b: matrix_b,
+          matrix_c: matrix_c, result: result }
+      end
 
-    def task_822(year:)
-      task(num: 822)
-      (year % 4).zero? ? '366 days' : '365 days'
-    end
+      def task_710(natural_number1:, natural_number2:)
+        task(num: 710)
+        m = Matrix.rows(new_matrix(n_lines: natural_number1,
+                                   m_lines: natural_number2))
+        m.transpose
+      end
 
-    def task_823(year1:, year2:)
-      task(num: 823)
-      leap_years = 0
-      (year1..year2).each { |y| leap_years += 1 if (y % 4).zero? }
-      leap_years
-    end
+      def task_822(year:)
+        task(num: 822)
+        (year % 4).zero? ? '366 days' : '365 days'
+      end
 
-    def task_831(year:)
-      task(num: 831)
-      october = Time.mktime(year, 10, 1)
-      day1 = october.wday
-      if day1 < 7
-        day = 7 - day1
-        Time.mktime(year, 10, day + 1)
-      else
-        Time.mktime(year, 10, day1)
+      def task_823(year1:, year2:)
+        task(num: 823)
+        leap_years = 0
+        (year1..year2).each { |y| leap_years += 1 if (y % 4).zero? }
+        leap_years
       end
-    end
 
-    def task_986
-      task(num: 986)
-      digit = rand(0..9)
-      digit_user = ''
-      3.times do
-        puts 'Guess the digit (0..9)'
-        digit_user = check_digit(digit: gets.to_i, lower_bound: 0, top_bound: 9)
-        break if digit_user == digit
+      def task_831(year:)
+        task(num: 831)
+        october = Time.mktime(year, 10, 1)
+        day1 = october.wday
+        if day1 < 7
+          day = 7 - day1
+          Time.mktime(year, 10, day + 1)
+        else
+          Time.mktime(year, 10, day1)
+        end
+      end
 
-        puts hint(digit1: digit_user, digit2: digit)
+      def task_986
+        task(num: 986)
+        digit = rand(0..9)
+        digit_user = ''
+        3.times do
+          puts 'Guess the digit (0..9)'
+          digit_user = check_digit(digit: gets.to_i,
+                                   lower_bound: 0,
+                                   top_bound: 9)
+          break if digit_user == digit
+
+          puts hint(digit1: digit_user, digit2: digit)
+        end
+        puts digit_user != digit ? "Right digit -  #{digit}" : 'Right you are!'
       end
-      puts digit_user != digit ? "You did not guess #{digit}" : 'Right you are!'
-    end
 
-    # select horse, task 988
-    def select_horse
-      puts horses = { 1 => 'Watercolor', 2 => 'Alpha', 3 => 'Gallop' }
-      puts 'Select horses (1..3)'
-      horse_num = check_digit(digit: gets.to_i, lower_bound: 1, top_bound: 3)
-      puts horses[horse_num]
-      horse_num
-    end
+      # select horse, task 988
+      def select_horse
+        puts horses = { 1 => 'Watercolor', 2 => 'Alpha', 3 => 'Gallop' }
+        puts 'Select horses (1..3)'
+        horse_num = check_digit(digit: gets.to_i, lower_bound: 1, top_bound: 3)
+        puts horses[horse_num]
+        horse_num
+      end
 
-    # place of the horse, task 988
-    def horses_num(run:, horse_num:)
-      run.map! { |x| x + rand(1..100) }
-      text = if run[horse_num - 1] == run.max
-               'First'
-             elsif run[horse_num - 1] == run.min
-               'Last'
-             else
-               'Second'
-             end
-      puts text
-      run
-    end
+      # place of the horse, task 988
+      def horses_num(run:, horse_num:)
+        run.map! { |x| x + rand(1..100) }
+        text = if run[horse_num - 1] == run.max
+                 'First'
+               elsif run[horse_num - 1] == run.min
+                 'Last'
+               else
+                 'Second'
+               end
+        puts text
+        run
+      end
 
-    def task_988
-      task(num: 988)
-      horse_num = select_horse
-      finish = 500
-      horses_run = []
-      3.times { horses_run.push(rand(1..100)) }
-      while horses_run.max < finish
-        horses_run = horses_num(run: horses_run, horse_num: horse_num)
+      def task_988
+        task(num: 988)
+        horse_num = select_horse
+        finish = 500
+        horses_run = []
+        3.times { horses_run.push(rand(1..100)) }
+        while horses_run.max < finish
+          horses_run = horses_num(run: horses_run, horse_num: horse_num)
+        end
+        puts horses_run[horse_num - 1] >= finish ? 'Victory!' : 'Try again.'
       end
-      puts horses_run[horse_num - 1] >= finish ? 'Victory!' : 'Try again.'
-    end
 
-    # result game 100 matches
-    def matches_result(first:, second:)
-      if first > second
-        'First is won'
-      elsif first == second
-        'Won friendship'
-      else
-        'Second is won'
+      # result game 100 matches
+      def matches_result(first:, second:)
+        if first > second
+          'First is won'
+        elsif first == second
+          'Won friendship'
+        else
+          'Second is won'
+        end
       end
-    end
 
-    def task_1009
-      puts 'Game - 100 matches \n must take from 1 to 10 matches'
-      first_player = 0
-      second_player = 0
-      until first_player >= 100 || second_player >= 100
-        puts 'first player'
-        first_player += check_digit(digit: gets.to_i)
-        puts 'second player'
-        second_player += check_digit(digit: gets.to_i)
-      end
-      puts matches_result(first: first_player, second: second_player)
+      def task_1009
+        puts 'Game - 100 matches \n must take from 1 to 10 matches'
+        first_player = 0
+        second_player = 0
+        until first_player >= 100 || second_player >= 100
+          puts 'first player'
+          first_player += check_digit(digit: gets.to_i)
+          puts 'second player'
+          second_player += check_digit(digit: gets.to_i)
+        end
+        puts matches_result(first: first_player, second: second_player)
+      end
     end
   end
 end

data/tasks.gemspec

@@ -25,5 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.17"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_dependency "run_tests", "~> 0.1.1"
+  spec.add_dependency "run_tests", "~> 0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tasks_gem
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - marina8915
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-04 00:00:00.000000000 Z
+date: 2018-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.1.2
 description: 
 email:
 - nonalatus@ukr.net
@@ -73,9 +73,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".travis.yml"
+- ".gitignire"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.travis.yml

@@ -1,7 +0,0 @@
----
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 2.5.3
-before_install: gem install bundler -v 1.17.1