tasks_gem 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd96ae937fc15db47c14928c75ad5b6b92954c3e05b57f8803d8cab9642687c1
-  data.tar.gz: 88b45e987ee6973bacc9312bfbda4a5f52d897776332d15ffecc9a2a948ae839
+  metadata.gz: fd37558cf32e19b0958c6fa0685db95695bc0a86bd1b6b0990550cd882fa3fee
+  data.tar.gz: e54c32ec88ef3751f96714c477c1df1699c9d0d19f4f96479cdfd8d2ab15b9b1
 SHA512:
-  metadata.gz: d999301cdb9ae60f9e43c3405a3d7739e27ea3f916ba2dd5685c85f8ff217b8655abf95c595829f8bda1467edbdc16ee356ea6e8f651d70a9904b38673c7abbf
-  data.tar.gz: 254e3c76ea56e0126e9cc18e391cd708c69d7eefab193eb9ca0c899a98f726d817957b642005689d5f4087c2a93b931195849c12f6d690fbbfe93f2131f34544
+  metadata.gz: 9fe439a7fefbb6c3ca8c97bbce94db15bbaddb745c1c8ad31257e21a0b10c576998a75c03cd888f5573823096cccdcac4d1752d8e89b200a0411ab37947e5f2e
+  data.tar.gz: 8c2918b7802a730d3820153927d3115750d0d1667df0218b508352c690ea66389e8658a763bc3be3f05a450ae4fb2a8c4d781a7f26b4a76a6420164a47569e21

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    tasks_gem (0.1.5)
-      run_tests (~> 0.1.2)
+    tasks_gem (0.1.7)
+      run_tests (~> 0.1.3)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -35,9 +35,11 @@ All methods:
 ```ruby
 print Tasks::Task.methods(false), "\n"
 ```
+Example use: https://github.com/marina8915/tasks-rails
+
 ## Dependencies:
 
-run_tests ~> 0.1.3
+run_tests ~> 0.1.1
 https://rubygems.org/gems/run_tests
 
 ## Development

data/lib/tasks/version.rb

@@ -1,3 +1,3 @@
 module Tasks
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/lib/tasks.rb

@@ -7,10 +7,6 @@ module Tasks
   # 50 tasks
   class Task
     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)
@@ -28,7 +24,6 @@ module Tasks
           array[i] = []
           (0..(m_lines - 1)).each { array[i].push(rand(1..10)) }
         end
-        print array, "\n"
         array
       end
 
@@ -46,7 +41,6 @@ module Tasks
       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
 
@@ -59,142 +53,122 @@ module Tasks
         end
       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 }
+      def task_1(a:, b:)
+        sum = a + b
+        diff = a - b
+        mult = a * b
+        { sum: sum.round(2),
+          difference: diff.round(2),
+          multiplication: mult.round(2)
+        }
       end
 
-      def task_2(number_a:, number_b:)
-        task(num: 2)
-        difference = number_a.abs - number_b.abs
-        multiplication = (number_a * number_b).abs
+      def task_2(x:, y:)
+        difference = x.abs - y.abs
+        multiplication = (x * y).abs
         (difference / (1 + multiplication)).round(4)
       end
 
       def task_3(edge_length:)
-        task(num: 3)
         volume = edge_length**3
         square = edge_length**2 * 6
-        { Volume: volume, Square: square }
+        { Volume: volume.round(2), Square: square.round(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 }
+        hypotenuse = Math.sqrt(cathetus_a**2 + cathetus_b**2).round(2)
+        square = (cathetus_a * cathetus_b / 2).round(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)
+        { Perimeter: 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_10(height:)
-        task(num: 10)
         result = Math.sqrt((2 * height) / 9.81)
-        result.round(2)
+        { time: 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)
+        { Square: result.round(2) }
       end
 
       def task_13(pendulum_length:)
-        task(num: 13)
-        (2 * 3.14 * Math.sqrt(pendulum_length / 9.81)).round(2)
+        result = (2 * 3.14 * Math.sqrt(pendulum_length / 9.81)).round(2)
+        { period: result }
       end
 
       def task_15(cathetus_a:, hypotenuse:)
-        task(num: 15)
-        cathetus_b = Math.sqrt(hypotenuse**2 - cathetus_a**2).round(2)
+        cathetus_b = Math.sqrt(hypotenuse**2 - cathetus_a**2)
         square = ((cathetus_a + cathetus_b - hypotenuse) / 2).round(2)
-        { cathetus_b: cathetus_b,
-          Square: square }
+        { cathetus_b: cathetus_b.round(2), Square: square }
       end
 
       def task_16(circumference:)
-        task(num: 16)
         result = Math::PI * Math.sqrt(circumference / (2 * Math::PI))
-        result.round(2)
+        { Square: 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)
+      def task_24(x1:, x2:, y1:, y2:)
+        diff_x = x1 - x2
+        diff_y = y1 - y2
+        result = Math.sqrt(diff_x**2 + diff_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
+      def task_30(x:)
+        degree3 = x**3
+        middle = 2 * x + 3 * x**2
         res1 = 1 - middle - 4 * degree3
         res2 = 1 + middle + 4 * degree3
-        { result1: res1, result2: res2 }
+        { result1: res1.round(2), result2: res2.round(2) }
       end
 
-      def task_33(real_number_x:, real_number_y:)
-        task(num: 33)
-        array = [real_number_x, real_number_y]
+      def task_33(x:, y:)
+        array = [x, 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]
+      def task_34(x:, y:, z:)
+        array = [x, y, 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 }
+      def task_41(x:, y:, z:)
+        array = [x, y, z]
+        array.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 }
+      def task_43(x:, y:, z:)
+        array = [x, y, z]
+        array.select { |x| x > 0 }.map { |x| x**2 }
       end
 
-      def task_62(integer:)
-        task(num: 62)
-        (integer % 2).zero?
+      def task_62(digit:)
+        digit.to_i
+        (digit % 2).zero? ? 'yes' : 'no'
       end
 
-      def task_64(natural_number:)
-        task(num: 64)
-        natural_number / 100
+      def task_64(digit:)
+        (digit / 100).to_i
       end
 
-      def task_65(natural_number:)
-        task(num: 65)
-        sum_array = number_array(digit: natural_number).reduce(:+)
-        sum_array**3 == natural_number**2
+      def task_65(digit:)
+        sum_array = number_array(digit: digit).reduce(:+)
+        sum_array**3 == digit**2 ? 'yes' : 'no'
       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
+      def task_67(digit:)
+        digit.to_i
+        array = number_array(digit: digit)
+        penultimate_number = array[array.length - 2] if digit >= 10
         { digits_number: array.length,
           sum: array.reduce(:+),
           last_digit: array[array.length - 1],
@@ -202,19 +176,15 @@ module Tasks
           penultimate_number: penultimate_number }
       end
 
-      def task_182(natural_number:)
-        task(num: 182)
-        array = new_array(quantity: natural_number)
+      def task_182(n:)
+        array = new_array(quantity: n.to_i)
         array2 = array.select { |elem| (elem % 5).zero? && elem % 7 != 0 }
         sum = array2.reduce(:+)
-        { arr_new: array2,
-          sum: sum,
-          quantity: array2.length }
+        { arr_new: array2, sum: sum, quantity: array2.length }
       end
 
-      def task_185(natural_number:)
-        task(num: 185)
-        array = new_array(quantity: natural_number)
+      def task_185(n:)
+        array = new_array(quantity: n.to_i)
         array2 = array.select { |elem| elem > 0 }
         sum = if array2 != []
                 array2.reduce(:+)**2
@@ -224,10 +194,9 @@ module Tasks
         { array: array2, sum: sum }
       end
 
-      def task_191(natural_number:)
-        task(num: 191)
+      def task_191(n:)
         quantity = 0
-        array = new_array(quantity: natural_number)
+        array = new_array(quantity: n.to_i)
         array.map! do |elem|
           quantity += 1 if elem > 7
           elem > 7 ? 7 : elem
@@ -235,38 +204,33 @@ module Tasks
         { 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(:+) }
+      def task_205(n:)
+        array = new_array(quantity: n.to_i)
+        max = array.map(&:abs).max
+        sum = Math.sqrt(array.map { |x| x * x }.reduce(:+))
+        { array: array, max: max, sum: sum }
       end
 
-      def task_207(natural_number:)
-        task(num: 207)
-        arr = number_array(digit: natural_number).delete_if do |x|
+      def task_207(n:)
+        arr = number_array(digit: n.to_i).delete_if do |x|
           x.zero? || x == 5
         end
         arr.join.to_i
       end
 
-      def task_224(natural_number:)
-        task(num: 224)
-        (1..natural_number).select { |x| (natural_number % x).zero? }
+      def task_224(n:)
+        n.to_i
+        (1..n).select { |x| (n % 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
-        end
+      def task_225(n:)
+        n.to_i
+        (1..n).select {|x| (n % x**2).zero? && n % x**3 != 0 }
       end
 
-      def task_230(natural_number:)
-        task(num: 230)
+      def task_230(n:)
         min = 1000
-        num_array = new_array(quantity: natural_number)
+        num_array = new_array(quantity: n.to_i)
         num_array.inject do |x, y|
           min = (x - y).abs if (x - y).abs < min
           y
@@ -274,66 +238,59 @@ module Tasks
         min
       end
 
-      def task_272(natural_number = 50)
-        task(num: 272)
-        precipitation = new_array(quantity: natural_number,
+      def task_272(n:)
+        precipitation = new_array(quantity: n.to_i,
                                   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 }
+        { precipitation: 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!
+      def task_279(n:)
+        n.to_i
+        a = new_array(quantity: n)
+        b = new_array(quantity: n).reverse!
         ab = []
-        (0..natural_number - 1).each { |i| ab.push(a[i] + b[i]) }
+        (0..n - 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)
+      def task_302(n:)
+        number = number_array(digit: n.to_i)
         number.uniq!
         number.length
       end
 
-      def task_317(natural_number = 10)
-        task(num: 317)
-        array = new_array(quantity: natural_number)
+      def task_317(n:)
+        array = new_array(quantity: n.to_i)
         sum_array = 0
-        (0..natural_number - 1).each { |i| sum_array += array[i]**(i + 1) }
+        (0..n - 1).each { |i| sum_array += array[i]**(i + 1) }
       end
 
-      def task_325(natural_number:)
-        task(num: 325)
-        separators = (1..natural_number).select do |x|
-          (natural_number % x).zero?
+      def task_325(n:)
+        n.to_i
+        separators = (1..n).select do |x|
+          (n % 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))
+      def task_328
+        array_separators(array: (1..100))
       end
 
-      def task_536(natural_number:)
-        task(num: 536)
-        array = new_array(quantity: natural_number)
-        { array: array, identical_elements: array != array.uniq }
+      def task_536(n:)
+        array = new_array(quantity: n.to_i)
+        result = array != array.uniq ? 'yes' : 'no'
+        { array: array, identical_elements: result }
       end
 
-      def task_555(natural_number:)
-        task(num: 555)
-        puts 'pascals triangle'
+      def task_555(n:)
+        n.to_i
         a = []
-        (0..natural_number - 1).each do |i|
+        (0..n - 1).each do |i|
           a[i] = []
           a[i].push(1)
           if i > 0
@@ -342,15 +299,14 @@ module Tasks
             end
             a[i].unshift(1)
           end
-          print a[i], "\n"
         end
         a
       end
 
-      def task_561(natural_number:)
-        task(num: 561)
+      def task_561(n:)
+        n.to_i
         new_array = []
-        (1..natural_number).each do |s|
+        (1..n).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)
@@ -359,113 +315,85 @@ module Tasks
         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]
+      def task_606(a:, b:, c:, d:)
+        rectangle = [a, b, c, d]
         sum = rectangle.reduce(:+)
         rectangle_flag = true
         (0..3).each do |i|
           rectangle_flag = false if (sum - rectangle[i]) < rectangle[i]
         end
-        rectangle_flag
+        rectangle_flag ? 'yes' : 'no'
       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))
+      def task_697(k:, m:, l:)
+        k.to_i
+        m.to_i
+        l.to_i
+        matrix_a = Matrix.rows(new_matrix(n_lines: k, m_lines: m))
+        matrix_b = Matrix.rows(new_matrix(n_lines: m, m_lines: l))
         mult = matrix_a * matrix_b
-        { matrix_a: matrix_a,
-          matrix_b: matrix_b,
-          result: mult }
+        { matrix_a: matrix_a, matrix_b: matrix_b, result: mult }
       end
 
-      def task_698(natural_number:)
-        task(num: 698)
-        matrix = Matrix.rows(new_matrix(n_lines: natural_number,
-                                        m_lines: natural_number))
+      def task_698(n:)
+        n.to_i
+        matrix = Matrix.rows(new_matrix(n_lines: n, m_lines: n))
         { matrix: matrix, result: matrix**2 }
       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))
+      def task_699(n:)
+        n.to_i
+        matrix_a = Matrix.rows(new_matrix(n_lines: n, m_lines: n))
+        matrix_b = Matrix.rows(new_matrix(n_lines: n, m_lines: n))
         result = matrix_a * matrix_b - matrix_b * matrix_a
         { matrix_a: matrix_a, matrix_b: matrix_b, result: result }
       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))
+      def task_704(n:)
+        n.to_i
+        matrix_a = Matrix.rows(new_matrix(n_lines: n, m_lines: n))
+        matrix_b = Matrix.rows(new_matrix(n_lines: n, m_lines: n))
+        matrix_c = Matrix.rows(new_matrix(n_lines: n, m_lines: n))
         result = (matrix_a + matrix_b) * matrix_c
         { matrix_a: matrix_a, matrix_b: matrix_b,
           matrix_c: matrix_c, 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
+      def task_710(m:, n:)
+        matrix = Matrix.rows(new_matrix(n_lines: m.to_i, m_lines: n.to_i))
+        matrix.transpose
       end
 
       def task_822(year:)
-        task(num: 822)
+        year.to_i
         (year % 4).zero? ? '366 days' : '365 days'
       end
 
-      def task_823(year1:, year2:)
-        task(num: 823)
+      def task_823(n:, m:)
+        n.to_i
+        m.to_i
         leap_years = 0
-        (year1..year2).each { |y| leap_years += 1 if (y % 4).zero? }
+        (n..m).each { |y| leap_years += 1 if (y % 4).zero? }
         leap_years
       end
 
-      def task_831(year:)
-        task(num: 831)
-        october = Time.mktime(year, 10, 1)
+      def task_831(n:)
+        n.to_i
+        october = Time.mktime(n, 10, 1)
         day1 = october.wday
         if day1 < 7
           day = 7 - day1
-          Time.mktime(year, 10, day + 1)
+          Time.mktime(n, 10, day + 1)
         else
-          Time.mktime(year, 10, day1)
+          Time.mktime(n, 10, day1)
         end
       end
 
-      def task_986
-        task(num: 986)
+      def task_986(n:)
+        n.to_i
         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
-
-      # 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
+        digit_user = check_digit(digit: n, lower_bound: 0, top_bound: 9)
+        digit_user != digit ? hint(digit1: digit_user, digit2: digit) : 'Right you are!'
       end
 
       # place of the horse, task 988
@@ -482,16 +410,15 @@ module Tasks
         run
       end
 
-      def task_988
-        task(num: 988)
-        horse_num = select_horse
+      def task_988(horse_num:)
+        horse = (1..3).include? horse_num.to_i ? horse_num : 1
         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)
+          horses_run = horses_num(run: horses_run, horse_num: horse)
         end
-        puts horses_run[horse_num - 1] >= finish ? 'Victory!' : 'Try again.'
+        horses_run[horse_num - 1] >= finish ? 'Victory!' : 'Try again.'
       end
 
       # result game 100 matches

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tasks_gem
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - marina8915
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-06 00:00:00.000000000 Z
+date: 2018-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,6 +87,7 @@ files:
 - tasks.gemspec
 - tasks_gem-0.1.0.gem
 - tasks_gem-0.1.4.gem
+- tasks_gem-0.1.5.gem
 homepage: https://github.com/marina8915/tasks_gem
 licenses:
 - MIT