mathsuite_gem 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d05302df4fb048e09d80295e464559ce6c91b5c2a7c1956cf557ab851fa36b9b
+  data.tar.gz: 025473fde133a319afc7e5f6c8f55836e63e4632bf32301a1f28fff90d89b242
+SHA512:
+  metadata.gz: 35d5dba671ffb78ce1a42432c9bd253eba40c6f5a582631b57dfb4fe9bb4fbea20ca212b7ff6818cad920a487170e30cf72b3a6efc3ce4b8408e62c9d71c7fa5
+  data.tar.gz: 6293f85c8c3f572e88a059632cb4ad529c3f96a16ce6d6182253fea78127be4e7b5c7e675dce6619fcaa3be905b20d89df628e4e44f75d534b66f59fe2e6c6fe

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 westnick2
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Mathsuite
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/mathsuite`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mathsuite'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mathsuite
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/mathsuite. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Mathsuite project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/mathsuite/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/mathsuite.rb

@@ -0,0 +1,327 @@
+
+  class Mathsuite
+    class << self
+
+      def dz1(a, b)
+        { summa: a+b, diff: a-b, multiply: a*b }
+      end
+
+      def dz2(x, y)
+        { value: (x.abs -y.abs)/(1+(x*y).abs) }
+      end
+
+      def dz3(x)
+        { volume: x**3,surface_area: x**2}
+      end
+
+      def dz4(x, y)
+        { sr_arifmet: (x+y)/2, sr_geometr: Math.sqrt(x*y)}
+      end
+
+      def dz5(x, y)
+        { sr_arifmet: (x+y)/2, sr_geometr: Math.sqrt(x.abs*y.abs)}
+      end
+
+      def dz6(x, y)
+        { gipotenuza: Math.sqrt(x**2+y**2), square: (x.abs*y.abs)/2}
+      end
+
+      def dz7(v1, t1, v2, t2)
+        { volume_M3: (v1+v2)/1000, temperature: (v1*1*t1+v2*1*t2)/(v1*1+v2*1) }
+      end
+
+      def dz8(n, r)
+        { Perimetr: r*Math.tan(360/(2*n))*2*n}
+      end
+
+      def dz9(r1, r2, r3)
+        { resistance: (r1*r2*r3)/(r2*r3+r1*r3+r1*r2)}
+      end
+
+      def dz10(h)
+        { falling_time: Math.sqrt(2*h/9.8) }
+      end
+
+      def dz11(x, y, z)
+        { a: (Math.sqrt((x-1).abs)-(y.abs)**1.0/3.0)/(1+x**2/2+y**2/4) , b: x*(Math.atan(z)+Math.exp(-x-3))}
+      end
+
+      def dz12(a)
+        { triangel_square: a**2*Math.sqrt(3)/4}
+      end
+
+      def dz13(l)
+        { Period_mayatnika: 2*Math::PI * Math.sqrt(l)/9.8}
+      end
+
+      def dz14(m1, m2, r)
+        g = 6.7385/10**11
+        if r.nonzero?
+          f = g.to_f*m1*m2/r**2
+        else
+          f = 0
+        end
+      end
+
+      def dz15(a, b)
+        c = Math.sqrt(a**2-b**2)
+        p = (a+b+c)/2
+        r = Math.sqrt((p-a)*(p-b)*(p-c)/p)
+        { katet2: c, radius: r}
+      end
+
+      def dz16(p)
+        { square: p**2/(8*Math::PI)}
+      end
+
+      def dz17(r1,r2)
+        { circle_square: Math::PI*(r2**2-r1**2)/2}
+      end
+
+      def dz18(a, b, c)
+        a = 2*r* Math.sin(alpha*Math::PI/180)
+        b = 2*r* Math.sin(beta*Math::PI/180)
+        c = 2*r* Math.sin(gama*Math::PI/180)
+        {a: a,b: b,c: c}
+      end
+
+      def dz19(v1, v2, a1, a2, s)
+        t = ((-2*(v1+v2))+Math.sqrt(4*((v1+v2)**2)+8*(a1+a2)*s))/2*(a1+a2);
+        { t: t}
+      end
+
+      def dz20(a, d, n)
+        { summa: (2*a + d*(n-1))*n/2}
+      end
+
+      def dz33(x, y)
+        a = [x,y]
+        var_max = a.max()
+        var_min = a.min()
+        { max: var_max, min:var_min}
+      end
+
+      def dz34(x, y, z)
+        a = [x,y,z]
+        var_max = a.max()
+        var_min = a.min()
+        [{ max: var_max}, {min:var_min, max1: var_max}]
+      end
+
+      def dz35(x, y, z)
+        a = [x+y+z,x*y*z]
+        b = [x+y+z/2.0,x*y*z]
+        var_max = a.max()
+        var_min = b.min()**2+1
+        { max: var_max, min:var_min }
+      end
+
+      def dz36(a, b, c)
+        if a<b &&b<c
+          {a_Less_b_Less_c: true}
+        else
+          {a_Less_b_Less_c: false}
+        end
+      end
+
+      def dz37(a, b, c)
+        if c<=b &&b<=a
+          [a,b,c].each {|x| x*2}
+        else
+          [a,b,c].each {|x| x.abs}
+        end
+      end
+
+      def dz38(x,y)
+        if x>y
+          z = x-y
+        else
+          z = y-x+1
+        end
+        { z: z}
+      end
+
+      def dz39(x, y)
+        if x>y
+          z =x
+        else
+          z = [x,y]
+        end
+        { z: z}
+      end
+
+      def dz40(x, y)
+        x=0 if x <= y
+        { result: [x, y] }
+      end
+
+      def dz41(x, y, z)
+        { res: [x,y,z].select {|a| (a>1) && (a<3) }}
+      end
+
+      def dz42(x, y)
+        if x == y
+          return "must be x!=y"
+        elsif x<y
+          x_tmp = x
+          x = (x+y)/2.0
+          y = 2*x_tmp*y
+        else
+          y_tmp = y
+          y = (x+y)/2.0
+          x = 2*y_tmp*x
+        end
+        { res: [x, y]}
+      end
+
+      def dz43(x, y, z)
+        { res: [x,y,z].each {|a| a = a**2 if a >= 0} }
+      end
+
+      def dz77(n)
+        fact = n.downto(1).inject(:*)
+        { n2: 2**n, fact: fact}
+      end
+
+      def dz196()
+        ar = []
+        x =10
+        1.upto(50) do
+          ar.push(x)
+          x+=1
+        end
+        { arB: ar.each.map { |x| if x.odd?
+                                   x=x*2
+                                 else
+                                   x = x
+                                 end } }
+      end
+
+      def dz200(a, n)
+        if !((1..n).to_a.include?(a))
+          return 0
+        else
+          i = 0
+          (1..n).to_a.each do |x|
+            if x==a
+              return i
+            end
+            i+=1
+          end
+        end
+        { res: "no #{a} in sequence"}
+      end
+
+      def dz204(n)
+        score = []
+        1.upto(n) {|x| score.push (x+2) }
+        score.sort!.shift
+        score.pop
+        { score: score.inject{ |sum, el| sum + el }.to_f/score.size }
+      end
+
+      def dz205(str)
+        { res: str.chars.delete_if { |x| x=="0"||x=="5" }.join }
+      end
+
+      def dz224(n)
+        { res: (1..n).select { |x| x = x if (n % x).zero?} }
+      end
+
+      def dz225(n)
+        { res: (1..n).select { |x| (n % x**2).zero? && (n % x**3).nonzero?} }
+      end
+
+      def dz251(str)
+        { res:str.chars.count("x")}
+      end
+
+      def dz258(str, char1)
+        { res: str.chars.delete(char1) }
+      end
+
+      def dz259(str, char1)
+        ar = str.chars.delete_if{|x| x== char1 }
+        { res: ar.map { |x| x = x + x if x!=char1 } }
+      end
+
+      def dz330(n)
+        res = []
+        1.upto(n) do |x|
+          ar = (1..x).select { |y| (n % y).zero? ? y = y : y = 0}
+          if x.equal?(ar.sum())
+            res.push(x)
+          end
+        end
+        { res_perfect_num: res}
+      end
+
+      def dz331(num)
+        res  = []
+        1.upto(num) do |x|
+          1.upto(num) do |y|
+            1.upto(num) do |z|
+              summa = (x**2) + (y**2) + (z**2)
+              res.push([x,y,z]) if summa.equal?(num)
+            end
+          end
+        end
+        { res_num: res}
+      end
+
+      def dz332(num)
+        res  = []
+        1.upto(num) do |x|
+          1.upto(num) do |y|
+            1.upto(num) do |z|
+              1.upto(num) do |t|
+                summa = (x**2) + (y**2) + (z**2)+(t**2)
+                res.push([x,y,z,t]) if summa.equal?(num)
+              end
+            end
+          end
+        end
+      end
+
+      def dz347(array)
+        mmin = array.min
+        mmax = array.max
+        enumer = mmin..mmax
+        { numbers: enumer.reject { |x| array.include?(x) } }
+      end
+
+      def dz434(aarr, barr)
+        ares = aarr.map.with_index { |x, i| i > aarr.index(aarr.max)? x = 0.5 : x }
+        bres = barr.map.with_index { |x, i| i > barr.index(barr.max)? x = 0.5 : x}
+        { ares: ares, bres: bres}
+      end
+
+      def dz435(aarr, barr, k)
+        aarr[aarr.index(aarr.max)] = k unless aarr.include?(k)
+        barr[barr.index(barr.max)] = k unless barr.include?(k)
+        { aarr: aarr, barr: barr}
+      end
+
+      def dz462(char1)
+        if (('a'..'z').include?(char1)) || (('A'..'Z').include?(char1))
+          { is_a_letter?: true }
+        else
+          { is_a_letter?: false }
+        end
+      end
+
+      def dz468(str1, str2)
+        flag = false
+        str2.chars.each do |x|
+          flag = str1.include?(x)
+          return { sym: x, index: str1.chars.index(x)} if flag
+        end
+        -1 unless flag
+      end
+
+      def dz469(str1, width)
+        delta = width - str1.size
+        str1.chars.select { |char| char == " " ? (char << " ") : (char = char) }.join
+      end
+    end
+  end

data/mathsuite.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |s|
+  s.name        = 'mathsuite_gem'
+  s.version     = '1.0.1'
+  s.date        = '2018-11-12'
+
+  s.summary     = "Solving Abramov book math tasks."
+  s.description = "This gem will help you to solve Abramov book math tasks."
+
+  s.authors     = ["Metelap Vlad"]
+  s.email       = 'vmetww@gmail.com'
+
+  s.files       = ["lib/mathsuite.rb"]
+  s.homepage    = 'https://github.com/westnick2/mathsuite'
+  s.license = 'GPL-2.0'
+
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'mathtestsuite', '~> 1.0'
+
+  s.files = [
+    'LICENSE.txt',
+    'README.md',
+    'Rakefile',
+    'mathsuite.gemspec',
+    'lib/mathsuite.rb',
+    'test/spec.rb'
+  ]
+
+  s.test_files = [
+    'test/spec.rb'
+  ]
+
+end

data/test/spec.rb

@@ -0,0 +1,300 @@
+load 'lib/mathsuite.rb'
+require 'mathtestsuite'
+
+class Spec
+  include Mathtestsuite
+
+  def dz1_t1
+    expected_value = { summa: -5, diff: 1, multiply: 6 }
+    assert(expected: expected_value, actual: Mathsuite.dz1(-2.0, -3.0))
+  end
+
+  def dz1_t2
+    expected_value = { summa: 9, diff: 5, multiply: 10 }
+    assert(expected: expected_value, actual: Mathsuite.dz1(-2.0, -3.0))
+  end
+
+  def dz2_t1
+    expected_value = {value: 0}
+    assert(expected: expected_value, actual: Mathsuite.dz2(-3.0, -3.0))
+  end
+
+  def dz3_t1
+    expected_value = {volume: 10**3,surface_area: 10**2}
+    assert(expected: expected_value, actual: Mathsuite.dz3(10))
+  end
+
+  def dz4_t1
+    expected_value = {sr_arifmet: 15.0, sr_geometr: Math.sqrt(10.0*20.0)}
+    assert(expected: expected_value, actual: Mathsuite.dz4(10, 20))
+  end
+
+  def dz5_t1
+    expected_value = {sr_arifmet: 10.0, sr_geometr: 10.0}
+    assert(expected: expected_value, actual: Mathsuite.dz5(10, 10))
+  end
+
+  def dz6_t1
+    expected_value = {gipotenuza: 5, square: 6.0}
+    assert(expected: expected_value, actual: Mathsuite.dz6(3.0, 4.0))
+  end
+
+  def dz7_t1
+    expected_value = {volume_M3: 30/1000, temperature: (10*1*40+20*1*20)/(10*1+20*1) }
+    assert(expected: expected_value, actual: Mathsuite.dz7(10.0, 40.0,20.0,20.0))
+  end
+
+  def dz8_t1
+    expected_value = {Perimetr: 5*Math.tan(360/(2*8))*2*8}
+    assert(expected: expected_value, actual: Mathsuite.dz8(8,5))
+  end
+
+  def dz9_t1
+    expected_value = {resistance: (10*15*25)/(15*25+10*25+10*15)}
+    assert(expected: expected_value, actual: Mathsuite.dz9(10,15,25))
+  end
+
+  def dz10_t1
+    expected_value = {falling_time: Math.sqrt(2*100/9.8) }
+    assert(expected: expected_value, actual: Mathsuite.dz10(100.0))
+  end
+
+  def dz11_t1
+    expected_value = {a: (Math.sqrt((10-1).abs)-(12.abs)**1.0/3.0)/(1+10**2/2+12**2/4) , b: 10*(Math.atan(15)+Math.exp(-10-3))}
+    assert(expected: expected_value, actual: Mathsuite.dz11(10,12,15))
+  end
+
+  def dz12_t1
+    expected_value = {triangel_square: 10**2*Math.sqrt(3)/4}
+    assert(expected: expected_value, actual: Mathsuite.dz12(10.0))
+  end
+
+  def dz13_t1
+    expected_value = {Period_mayatnika: 2*Math::PI * Math.sqrt(20)/9.8}
+    assert(expected: expected_value, actual: Mathsuite.dz13(20))
+  end
+
+  def dz14_t1
+    g = 6.7385/10**11
+    expected_value = {force_of_gravity: g*100*200/10**2}
+    assert(expected: expected_value, actual: Mathsuite.dz14(100,200,10,g))
+  end
+
+  def dz15_t1
+    gipotenuza = 5
+    katet = 4
+    katet2 = Math.sqrt(gipotenuza**2-katet**2)
+    p = (gipotenuza+katet+katet2)/2
+    r = Math.sqrt((p-gipotenuza)*(p-katet)*(p-katet2)/p)
+    expected_value = {katet2: katet2, radius: r}
+    assert(expected: expected_value, actual: Mathsuite.dz15(5,4))
+  end
+
+  def dz16_t1
+    expected_value = {square: 100**2/(8*Math::PI)}
+    assert(expected: expected_value, actual: Mathsuite.dz16(100.0))
+  end
+
+  def dz17_t1
+    expected_value = {circle_square: Math::PI*(30**2-20**2)/2}
+    assert(expected: expected_value, actual: Mathsuite.dz17(20,30))
+  end
+
+  def dz18_t1
+    a = 2*5* Math.sin(60*Math::PI/180)
+    b = 2*5* Math.sin(60*Math::PI/180)
+    c = 2*5* Math.sin(60*Math::PI/180)
+    expected_value = {a: a,b: b,c: c}
+    assert(expected: expected_value, actual: Mathsuite.dz18(60,60,60,5))
+  end
+
+  def dz19_t1
+    t = ((-2*(v1+v2))+Math.sqrt(4*((v1+v2)**2)+8*(a1+a2)*s))/2*(a1+a2);
+    expected_value = {t: t}
+    assert(expected: expected_value, actual: Mathsuite.dz19(50,60,10,5,1000))
+  end
+
+  def dz20_t1
+    expected_value = {summa: (2*3 + 2*(20-1))*20/2}
+    assert(expected: expected_value, actual: Mathsuite.dz20(3,2,20))
+  end
+
+  def dz33_t1
+    expected_value = {max: 100, min:20}
+    assert(expected: expected_value, actual: Mathsuite.dz33(20,100))
+  end
+
+  def dz34_t1
+    expected_value = [{max: 30}, {min:10, max1: 30}]
+    assert(expected: expected_value, actual: Mathsuite.dz34(10,20,30))
+  end
+
+  def dz35_t1
+    x = 10
+    y = 20
+    z = 30
+    a = [x+y+z,x*y*z]
+    b = [x+y+z/2.0,x*y*z]
+    var_max = a.max()
+    var_min = b.min()**2+1
+    expected_value = {max: var_max, min:var_min }
+    assert(expected: expected_value, actual: Mathsuite.dz35(10,20,30))
+  end
+
+  def dz36_t1
+    expected_value = {a_Less_b_Less_c: true}
+    assert(expected: expected_value, actual: Mathsuite.dz36(10,20,30))
+  end
+
+  def dz37_t1
+    expected_value = [900,400,100]
+    assert(expected: expected_value, actual: Mathsuite.dz37(30,20,10))
+  end
+
+  def dz38_t1
+    expected_value = {z: 30}
+    assert(expected: expected_value, actual: Mathsuite.dz38(50,20))
+  end
+
+  def dz39_t1
+    expected_value = {z: [50,100]}
+    assert(expected: expected_value, actual: Mathsuite.dz39(50,100))
+  end
+
+  def dz40_t1
+    expected_value = {result: [0,30]}
+    assert(expected: expected_value, actual: Mathsuite.dz40(10,30))
+  end
+
+  def dz41_t1
+    expected_value = {res: [2]}
+    assert(expected: expected_value, actual: Mathsuite.dz41(1,2,3))
+  end
+
+  def dz42_t1
+    expected_value = {res: [15,400]}
+    assert(expected: expected_value, actual: Mathsuite.dz42(10,20))
+  end
+
+  def dz43_t1
+    expected_value = {res: [4,9,25]}
+    assert(expected: expected_value, actual: Mathsuite.dz43(2,3,5))
+  end
+
+  def dz77_t1
+    expected_value = {n2: 32, fact: 120}
+    assert(expected: expected_value, actual: Mathsuite.dz77(5))
+  end
+
+  def dz196_t1
+    expected_value = {:arB=>[10, 22, 12, 26, 14, 30, 16, 34, 18, 38, 20, 42, 22, 46, 24, 50, 26, 54, 28, 58, 30, 62, 32,
+                             66, 34, 70, 36, 74, 38, 78, 40, 82, 42, 86, 44, 90, 46, 94, 48, 98, 50, 102, 52, 106, 54,
+                             110, 56, 114, 58, 118]}
+    assert(expected: expected_value, actual: Mathsuite.dz196())
+  end
+
+  def dz200_t1
+    expected_value = 9
+    assert(expected: expected_value, actual: Mathsuite.dz200(10,20))
+  end
+
+  def dz204_t1
+    expected_value = {:score=>12.5}
+    assert(expected: expected_value, actual: Mathsuite.dz204(20))
+  end
+
+  def dz207_t1
+    str = "59094715"
+    expected_value = {res: "99471" }
+    assert(expected: expected_value, actual: Mathsuite.dz207(str))
+  end
+
+  def dz224_t1
+    expected_value = {:res=>[1, 3, 37, 111]}
+    assert(expected: expected_value, actual: Mathsuite.dz224(111))
+  end
+
+  def dz225_t1
+    expected_value = {:res=>[25]}
+    assert(expected: expected_value, actual: Mathsuite.dz225(625))
+  end
+
+  def dz251_t1
+    str = "xkgiuxytuxgxgjkhkx"
+    expected_value = {:res=>5}
+    assert(expected: expected_value, actual: Mathsuite.dz251(str))
+  end
+
+  def dz258_t1
+    str = "qrabcdceyrejtabcdasryt"
+    char1 = "abcd"
+    expected_value = {:res=>"qreyrejtsryt"}
+    assert(expected: expected_value, actual: Mathsuite.dz258(str,char1))
+  end
+
+  def dz259_t1
+    str = "ge*t*s.*c*h**o*m*p"
+    char1 = "*"
+    expected_value = {:res=>"ggeettss..cchhoommpp"}
+    assert(expected: expected_value, actual: Mathsuite.dz259(str,char1))
+  end
+
+  def dz330_t1
+    expected_value = {:res_perfect_num=>[1]}
+    assert(expected: expected_value, actual: Mathsuite.dz330(1000))
+  end
+
+  def dz331_t1
+    expected_value = {:res_num=>[[2, 10, 14], [2, 14, 10], [10, 2, 14], [10, 10, 10], [10, 14, 2], [14, 2, 10], [14, 10, 2]]}
+    assert(expected: expected_value, actual: Mathsuite.dz331(300))
+  end
+
+  def dz332_t1
+    expected_value = {:res=>[[1, 1, 7, 7], [1, 3, 3, 9], [1, 3, 9, 3], [1, 5, 5, 7], [1, 5, 7, 5], [1, 7, 1, 7], [1, 7, 5, 5],
+                             [1, 7, 7, 1], [1, 9, 3, 3], [2, 4, 4, 8], [2, 4, 8, 4], [2, 8, 4, 4], [3, 1, 3, 9], [3, 1, 9, 3],
+                             [3, 3, 1, 9], [3, 3, 9, 1], [3, 9, 1, 3], [3, 9, 3, 1], [4, 2, 4, 8], [4, 2, 8, 4], [4, 4, 2, 8],
+                             [4, 4, 8, 2], [4, 8, 2, 4], [4, 8, 4, 2], [5, 1, 5, 7], [5, 1, 7, 5], [5, 5, 1, 7], [5, 5, 5, 5],
+                             [5, 5, 7, 1], [5, 7, 1, 5], [5, 7, 5, 1], [7, 1, 1, 7], [7, 1, 5, 5], [7, 1, 7, 1], [7, 5, 1, 5],
+                             [7, 5, 5, 1], [7, 7, 1, 1], [8, 2, 4, 4], [8, 4, 2, 4], [8, 4, 4, 2], [9, 1, 3, 3], [9, 3, 1, 3],
+                             [9, 3, 3, 1]]}
+    assert(expected: expected_value, actual: Mathsuite.dz332(100))
+  end
+
+  def dz347_t1
+    ar = [3,4,5,1,6,7,8,19]
+    expected_value = {:numbers=>[2, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]}
+    assert(expected: expected_value, actual: Mathsuite.dz347(ar))
+  end
+
+  def dz434_t1
+    aarray = [3,4,5,21,6,7,8,19]
+    barray = [31,4,5,1,6,7,8,19]
+    expected_value = {:ares=>[3, 4, 5, 21, 0.5, 0.5, 0.5, 0.5], :bres=>[31, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]}
+    assert(expected: expected_value, actual: Mathsuite.dz434(aarray,barray))
+  end
+
+  def dz435_t1
+    aarray = [3,4,5,21,6,7,8,19]
+    barray = [31,4,5,1,6,7,8,19]
+    expected_value = {:aarr=>[3, 4, 5, 21, 6, 7, 8, 19], :barr=>[31, 4, 5, 1, 6, 7, 8, 19]}
+    assert(expected: expected_value, actual: Mathsuite.dz435(aarray,barray,4))
+  end
+
+  def dz462_t1
+    expected_value = {is_a_letter?: true }
+    assert(expected: expected_value, actual: Mathsuite.dz462("g"))
+  end
+
+  def dz468_t1
+    str1 = "Hello world!"
+    str2 = "World hello"
+    expected_value = {:sym=>"o", :index=>4}
+    assert(expected: expected_value, actual: Mathsuite.dz468(str1,str2))
+  end
+
+  def dz469_t1
+    str1 = "Hello world good morning!"
+    expected_value = "Hello  world  good  morning!"
+    assert(expected: expected_value, actual: Mathsuite.dz469(str1, 25))
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: mathsuite_gem
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Metelap Vlad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mathtestsuite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: This gem will help you to solve Abramov book math tasks.
+email: vmetww@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mathsuite.rb
+- mathsuite.gemspec
+- test/spec.rb
+homepage: https://github.com/westnick2/mathsuite
+licenses:
+- GPL-2.0
+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.7.7
+signing_key: 
+specification_version: 4
+summary: Solving Abramov book math tasks.
+test_files:
+- test/spec.rb